name string | code string | asm string | file string |
|---|---|---|---|
Liby::TimerMixin::runAfter(Liby::Timestamp const&, std::function<void ()> const&) | TimerId TimerMixin::runAfter(const Timestamp ×tamp,
const BasicHandler &handler) {
static TimerMixinHelper helper(&loop_);
return runHelper(loop_->runAfter(timestamp, handler));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpb $0x0, 0x7c0fd(%rip) # 0x95670
jne 0x195a8
leaq 0x7c0f4(%rip), %rdi # 0x95670
callq 0x67f0
cmpl $0x0, %eax
je 0x195a8
movq -0x40(%rbp), %rsi
addq $0x8,... | /ccsexyz[P]liby-cpp/src/TimerMixin.cpp |
Liby::TimerMixin::runEvery(Liby::Timestamp const&, std::function<void ()> const&) | TimerId TimerMixin::runEvery(const Timestamp ×tamp,
const BasicHandler &handler) {
static TimerMixinHelper helper(&loop_);
return runHelper(loop_->runEvery(timestamp, handler));
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpb $0x0, 0x7c02d(%rip) # 0x95680
jne 0x19688
leaq 0x7c024(%rip), %rdi # 0x95680
callq 0x67f0
cmpl $0x0, %eax
je 0x19688
movq -0x40(%rbp), %rsi
addq $0x8,... | /ccsexyz[P]liby-cpp/src/TimerMixin.cpp |
Liby::PollerEpoll::PollerEpoll() | PollerEpoll::PollerEpoll() {
pollerfd_ = ::epoll_create1(EPOLL_CLOEXEC);
fatalif(pollerfd_ <= 0, "%s", ::strerror(errno));
pollerfp_ = std::make_shared<FileDescriptor>(pollerfd_);
events_.resize(defaultEpollSize);
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x1b5e0
movq -0x30(%rbp), %rdi
leaq 0x780cc(%rip), %rax # 0x94490
addq $0x10, %rax
movq %rax, (%rdi)
movl $0xffffffff, 0x68(%rdi) # imm = 0xFFFFFFFF
movq $0x0, 0x70(%rdi)
addq $0x78, %rdi
movq %rdi, ... | /ccsexyz[P]liby-cpp/src/PollerEpoll.cpp |
Liby::WeakTimerHolder::WeakTimerHolder(Liby::TimerHolder const&) | WeakTimerHolder(const TimerHolder &holder)
: timer_(holder.getTimer().id(), holder.getTimer().timeout(), nullptr),
weakTimerPtr_(holder.getTimerPtr()) {} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19810
movq %rax, %rdi
callq 0x19860
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19810
movq %rax, %rdi
callq 0x21740
movq %... | /ccsexyz[P]liby-cpp/src/TimerQueue.h |
Liby::EventQueue::EventQueue(Liby::Poller*) | EventQueue::EventQueue(Poller *poller) : poller_(poller) {
fatalif(poller_ == nullptr, "Poller cannot be nullptr");
#ifdef __linux__
eventfd_ = ::eventfd(1000, EFD_CLOEXEC | EFD_NONBLOCK);
fatalif(eventfd_ < 0, "eventfd create: %s", ::strerror(errno));
eventfp_ = std::make_unique<FileDescriptor>(eventfd... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movl $0xffffffff, 0x8(%rdi) # imm = 0xFFFFFFFF
addq $0x10, %rdi
movq %rdi, -0x60(%rbp)
callq 0x24f70
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
mov... | /ccsexyz[P]liby-cpp/src/EventQueue.cpp |
Liby::EventQueue::wakeup() | void EventQueue::wakeup() {
static int64_t this_is_a_number = 1;
int targetfd;
#ifdef __linux__
targetfd = eventfd_;
#elif defined(__APPLE__)
targetfd = event2fd_;
#endif
ClearUnuseVariableWarning(
::write(targetfd, &this_is_a_number, sizeof(this_is_a_number)));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0x70d90(%rip), %rsi # 0x954b0
movl $0x8, %edx
callq 0x6150
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x25440
addq $0x20, %rsp
popq %rbp
retq
nopl (%... | /ccsexyz[P]liby-cpp/src/EventQueue.cpp |
Liby::TimerQueue::updateTimerfd(Liby::Timestamp const&) | void TimerQueue::updateTimerfd(const Timestamp &timeout) {
#ifdef __linux
struct itimerspec new_timer;
new_timer.it_value.tv_sec = timeout.sec();
new_timer.it_value.tv_nsec = timeout.usec() * 1000;
new_timer.it_interval = {0, 0};
int ret = ::timerfd_settime(timerfd_, TFD_TIMER_ABSTIME, &new_timer, N... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20c90
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20cb0
movq %rax, %rcx
movq -0x50(%rbp), %rax
imulq $0x3e8, %rcx, %rcx # imm = 0x3E8
movq %... | /ccsexyz[P]liby-cpp/src/TimerQueue.cpp |
Liby::Buffer::backward(long) | void Buffer::backward(off_t offset) {
assert(offset >= 0);
if (offset == 0) {
if (rightIndex_ == capacity_) {
return;
}
::memmove(buffer_ + leftIndex_ + capacity_ - rightIndex_,
buffer_ + leftIndex_, capacity_ - rightIndex_);
leftIndex_ += capacity_ ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x29e21
jmp 0x29e40
leaq 0x33860(%rip), %rdi # 0x5d688
leaq 0x33697(%rip), %rsi # 0x5d4c6
movl $0xba, %edx
leaq 0x3387b(%rip), %rcx # 0x5d6b6
callq ... | /ccsexyz[P]liby-cpp/src/Buffer.cpp |
Liby::Buffer::resize(long) | void Buffer::resize(off_t minSize) {
if (minSize < capacity_)
return;
char *newBuffer = new char[minSize];
::memcpy(newBuffer + leftIndex_, buffer_ + leftIndex_, size());
delete[] buffer_;
buffer_ = newBuffer;
capacity_ = minSize;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jge 0x2a004
jmp 0x2a07d
movq -0x10(%rbp), %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x6030
movq -0x20(%rbp), %rdi
movq %r... | /ccsexyz[P]liby-cpp/src/Buffer.cpp |
Liby::EventLoopGroup::run(std::function<bool ()>) | void EventLoopGroup::run(BoolFunctor bf) {
Signal::signal(SIGPIPE, [] { error("receive SIGPIPE"); });
bf_ = bf;
for (int i = 0; i < n_; i++) {
threads_.emplace_back([this](int index) { worker_thread(index); },
i + 1);
}
worker_thread(0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x31(%rbp), %rsi
callq 0x2b610
movq -0x60(%rbp), %rsi
movl $0xd, %edi
callq 0x14e40
jmp 0x2b57d
leaq -0x30(%rbp... | /ccsexyz[P]liby-cpp/src/EventLoopGroup.cpp |
Liby::EventLoopGroup::worker_thread(int) | void EventLoopGroup::worker_thread(int index) {
assert(index >= 0 && index <= n_);
EventLoop &loop = *loops_[index];
if (loop.curr_thread_loop() == nullptr)
loop.bind_to_thread();
loop.setRobinFunctor([this](int fd) { return robinLoop(fd); });
loop.setRobinFunctor1([this](int fd) { return... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0xc1(%rbp)
jl 0x2b760
movq -0xd0(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
setle %al
movb %al, -0xc1(%... | /ccsexyz[P]liby-cpp/src/EventLoopGroup.cpp |
Liby::EventLoopGroup::creatUdpServer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::shared_ptr<UdpSocket>
EventLoopGroup::creatUdpServer(const std::string &host,
const std::string &service) {
auto eps = Resolver::resolve(host, service);
if (eps.empty()) {
error("host or service unavaiable");
return nullptr;
}
SockPtr sockPtr = std::m... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x... | /ccsexyz[P]liby-cpp/src/EventLoopGroup.cpp |
Liby::EventLoopGroup::creatUdpClient() | std::shared_ptr<UdpSocket> EventLoopGroup::creatUdpClient() {
SockPtr sockPtr = std::make_shared<Socket>(true);
sockPtr->setNoblock();
std::shared_ptr<UdpSocket> udpSocket =
std::make_shared<UdpSocket>(robinLoop1(sockPtr->fd()), sockPtr);
return udpSocket;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x1, -0x21(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x21(%rbp), %rsi
callq 0x2f450
movq -0x48(%rbp),... | /ccsexyz[P]liby-cpp/src/EventLoopGroup.cpp |
Liby::Connection::Connection(Liby::EventLoop*, std::shared_ptr<Liby::Socket> const&) | Connection::Connection(EventLoop *loop, const SockPtr &socket)
: poller_(loop->getPoller()), loop_(loop), socket_(socket), readBuf_(1024) {
assert(socket);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x48, %rdi
callq 0x39830
movq -0x30(%rbp), %rdi
callq 0x19320
jmp 0x366c0
movq -0x30(%rbp), %rdi
leaq 0x5e145(%rip), %rax # 0x94810
movq %rax, (%rdi)
add... | /ccsexyz[P]liby-cpp/src/Connection.cpp |
Liby::Connection::send(Liby::Buffer&&, std::function<void ()> const&) | void Connection::send(Buffer &&buf, const BasicHandler &handler) {
io_task task;
task.buffer_ = std::make_shared<Buffer>(std::move(buf));
if (handler) {
task.handler_ = std::make_unique<BasicHandler>(handler);
}
writTasks_.emplace_back(std::move(task));
enableWrit();
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x39ad0
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x39da0
jmp 0x370b7
leaq -0x50(%rbp), %rdi
addq $0x20, %rdi
leaq -0x60(%rb... | /ccsexyz[P]liby-cpp/src/Connection.cpp |
Liby::Connection::handleWritEvent() | void Connection::handleWritEvent() {
// if (writTasks_.empty()) {
//
// return;
// }
auto x = self_;
DeferCaller([this] {
if (destroy_)
return;
if (writTasks_.empty())
enableWrit(false);
});
// enableWrit(false);
// ssize_t... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x120(%rbp)
subq $-0x80, %rsi
leaq -0x18(%rbp), %rdi
callq 0xb5f0
movq -0x120(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x37e... | /ccsexyz[P]liby-cpp/src/Connection.cpp |
Liby::Connection::sendFile(std::shared_ptr<Liby::FileDescriptor> const&, long, long, std::function<void ()> const&) | void Connection::sendFile(const fdPtr &fp, off_t off, off_t len,
const BasicHandler &handler) {
io_task task;
task.fp_ = fp;
task.offset_ = off;
task.len_ = len;
if (handler) {
task.handler_ = std::make_unique<BasicHandler>(handler);
}
writTasks_.emplace_bac... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x39ad0
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xeee0
movq -0x18(%rbp), %rax... | /ccsexyz[P]liby-cpp/src/Connection.cpp |
Liby::TcpClient::start() | void TcpClient::start() {
// assert(connector_);
assert(loop_ && socket_ && poller_);
chan_ = std::make_shared<Channel>(poller_, socket_->fd());
chan_->enableRead(false)
.enableWrit()
.onWrit([this] {
auto x = shared_from_this();
// if (!socket_) {
... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x68(%rcx)
movb %al, -0x91(%rbp)
je 0x3de0f
movq -0xa0(%rbp), %rdi
addq $0x78, %rdi
callq 0x2fa20
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x91(%rbp)
jne 0x3ddfa
jmp ... | /ccsexyz[P]liby-cpp/src/TcpClient.cpp |
Liby::TcpClient::destroy() | void TcpClient::destroy() {
poller_ = nullptr;
loop_ = nullptr;
chan_.reset();
socket_
.reset(); // socket_.reset必须在chan_之后,确保chan_析构时其使用的fd是有效的
connector_ = nullptr;
self_.reset();
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x70(%rdi)
movq $0x0, 0x68(%rdi)
addq $0x88, %rdi
callq 0x39970
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0x399b0
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x... | /ccsexyz[P]liby-cpp/src/TcpClient.cpp |
Liby::TcpServer::TcpServer(Liby::EventLoop*) | TcpServer::TcpServer(EventLoop *loop)
: poller_(loop->getPoller()), loop_(loop) {} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x19320
movq -0x38(%rbp), %rdi
leaq 0x53a80(%rip), %rax # 0x94a18
movq %rax, (%rdi)
movl $0xffffffff, 0x48(%rdi) # imm = 0xFFFFFFFF
addq $0x50, %rdi
movq %rdi, -0x40(%rbp)
call... | /ccsexyz[P]liby-cpp/src/TcpServer.cpp |
Liby::TcpServer::initConnection(Liby::Connection&) | void TcpServer::initConnection(Connection &conn) {
conn.onRead(readEventCallback_).onErro([this](Connection &conn) {
auto x = conn.shared_from_this();
if (erroEventCallback_) {
erroEventCallback_(conn);
}
x->destroy();
});
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0x98, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8fd0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xb7a0
movq ... | /ccsexyz[P]liby-cpp/src/TcpServer.cpp |
parse_hex(char const*) | static char parse_hex(const char *s) noexcept {
int n1, n2;
if (*s >= '0' && *s <= '9')
n1 = *s - '0';
else {
char temp = *s | 32;
n1 = temp - 'a' + 10;
}
if (*(s + 1) >= '0' && *(s + 1) <= '9')
n2 = *(s + 1) - '0';
else {
char temp = *(s + 1) | 32;
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x554ef
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x554ef
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0xc(%rbp)
jmp 0x55509
movq -0x8(%rbp), %rax
movsbl (%rax), %... | /ccsexyz[P]liby-cpp/src/http/HttpDef.cpp |
wally_psbt_output_set_unknowns | int wally_psbt_output_set_blinding_pubkey(struct wally_psbt_output *output,
const unsigned char *pub_key,
size_t pub_key_len)
{
int ret;
if (!output || BYTES_INVALID(pub_key, pub_key_len))
return WALLY_EINVAL;
if (pu... | testq %rdi, %rdi
je 0x508e
movq %rdi, %rax
addq $0x38, %rax
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
jmp 0x4bc1
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
| /p2pderivatives[P]cfd-go/external/libwally-core/src/psbt.c |
wally_psbt_output_find_unknown | int wally_psbt_output_set_blinding_pubkey(struct wally_psbt_output *output,
const unsigned char *pub_key,
size_t pub_key_len)
{
int ret;
if (!output || BYTES_INVALID(pub_key, pub_key_len))
return WALLY_EINVAL;
if (pu... | testq %rcx, %rcx
je 0x50a0
movq $0x0, (%rcx)
testq %rdi, %rdi
je 0x50ae
addq $0x38, %rdi
jmp 0x46ab
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
| /p2pderivatives[P]cfd-go/external/libwally-core/src/psbt.c |
wally_psbt_output_add_unknown | int wally_psbt_output_set_blinding_pubkey(struct wally_psbt_output *output,
const unsigned char *pub_key,
size_t pub_key_len)
{
int ret;
if (!output || BYTES_INVALID(pub_key, pub_key_len))
return WALLY_EINVAL;
if (pu... | testq %rdi, %rdi
je 0x50d0
pushq %rax
addq $0x38, %rdi
xorl %r9d, %r9d
pushq $0x1
pushq $0x0
callq 0x475c
addq $0x10, %rsp
popq %rcx
retq
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
retq
| /p2pderivatives[P]cfd-go/external/libwally-core/src/psbt.c |
wally_psbt_add_input_at | int wally_psbt_add_input_at(struct wally_psbt *psbt,
uint32_t index, uint32_t flags,
const struct wally_tx_input *input)
{
struct wally_tx_input tmp;
int ret;
if (!psbt || !psbt->tx || psbt->tx->num_inputs != psbt->num_inputs ||
(flags & ~WALL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl $0xfffffffe, %ebp # imm = 0xFFFFFFFE
testq %rdi, %rdi
je 0x598c
movq %rdi, %rbx
movq 0x8(%rdi), %r12
testq %r12, %r12
je 0x598c
movl %edx, %r13d
cmpl $0x1, %edx
ja 0x598c
movq 0x10(%r12), %rax
cmpq 0x18(%rbx), %rax
jne 0x598c
... | /p2pderivatives[P]cfd-go/external/libwally-core/src/psbt.c |
Test_SUNLinSolLastFlag | int Test_SUNLinSolLastFlag(SUNLinearSolver S, int myid)
{
double start_time, stop_time;
long int lastflag;
/* the only way to fail this test is if the function is NULL,
which will cause a seg-fault */
start_time = get_time();
lastflag = SUNLinSolLastFlag(S);
stop_time = get_time();
if (myi... | pushq %rbx
movl %esi, %ebx
callq 0x321a
testl %ebx, %ebx
jne 0x2d4f
leaq 0x185b(%rip), %rdi # 0x4586
movq %rax, %rsi
xorl %eax, %eax
callq 0x2070
cmpl $0x0, 0x435c(%rip) # 0x7098
je 0x2d4f
leaq 0x186e(%rip), %rdi # 0x45b3
xorps %xmm0, %xmm0
movb $0x1, %al
callq 0x2070
xorl %eax, %eax
popq %rbx
retq
| /Cirdans-Home[P]kinsol-psblas/examples/sunlinsol/test_sunlinsol.c |
Test_SUNLinSolNumIters | int Test_SUNLinSolNumIters(SUNLinearSolver S, int myid)
{
int numiters;
double start_time, stop_time;
/* the only way to fail this test is if the function is NULL,
which will cause a seg-fault */
start_time = get_time();
numiters = SUNLinSolNumIters(S);
stop_time = get_time();
if (myid ==... | pushq %rbx
movl %esi, %ebx
callq 0x31e3
testl %ebx, %ebx
jne 0x2dfe
leaq 0x188f(%rip), %rdi # 0x466a
movl %eax, %esi
xorl %eax, %eax
callq 0x2070
cmpl $0x0, 0x42ad(%rip) # 0x7098
je 0x2dfe
leaq 0x18a2(%rip), %rdi # 0x4696
xorps %xmm0, %xmm0
movb $0x1, %al
callq 0x2070
xorl %eax, %eax
popq %rbx
retq
| /Cirdans-Home[P]kinsol-psblas/examples/sunlinsol/test_sunlinsol.c |
SUNLinSolSpace | int SUNLinSolSpace(SUNLinearSolver S, long int *lenrwLS,
long int *leniwLS)
{
if (S->ops->space)
return ((int) S->ops->space(S, lenrwLS, leniwLS));
else {
*lenrwLS = 0;
*leniwLS = 0;
return SUNLS_SUCCESS;
}
} | movq 0x8(%rdi), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0x323b
jmpq *%rax
andq $0x0, (%rsi)
andq $0x0, (%rdx)
xorl %eax, %eax
retq
| /Cirdans-Home[P]kinsol-psblas/src/sundials/sundials_linearsolver.c |
Scene::camera(double, double, Ray&) | void Scene::camera(double x, double y, Ray& ray)
{
ray.org = eye;
if (aperture > 0.0) // камера не точечная, исп с AdaptiveDistRenderScene
{
// построить случайную точку на линзе
Vector lens_point = (view_x * (double)rand() + view_y * (double)rand()) * aperture / RAND_MAX;
ray.org ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x48(%rdi), %xmm2
movsd %xmm2, (%rsi)
movsd 0x50(%rdi), %xmm2
movsd %xmm2, 0x8(%rsi)
movsd 0x58(%rdi), %xmm2
movsd %xmm2, 0x10(%rsi)
movsd 0xa8(%rdi), %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jbe 0x459e
movsd %xmm1, 0x10(%rsp)
movsd %xmm0... | /berkus[P]grayzer/src/environment/Scene.cpp |
Box::find_normal(Vector&) | Vector Box::find_normal( Vector& p )
{
double MinDist = INFINITY;
int index = 0;
double d,Dist1,Dist2;
Vector normal;
int i;
for( i = 0; i < 3; i++ )
{
d = p & n[i];
Dist1 = fabs(d + d1[i]);
Dist2 = fabs(d + d2[i]);
if( Dist1 < MinDist )
{
... | movq %rdi, %rax
movsd (%rdx), %xmm0
movsd 0x8(%rdx), %xmm1
movsd 0x10(%rdx), %xmm2
xorl %ecx, %ecx
movsd 0x254d(%rip), %xmm4 # 0x8210
movq $-0x9, %rdi
movapd 0x24de(%rip), %xmm3 # 0x81b0
xorl %r8d, %r8d
movsd 0x150(%rsi,%rdi,8), %xmm5
mulsd %xmm1, %xmm5
movsd 0x148(%rsi,%rdi,8), %xmm6
mulsd %xmm0, %xmm6
addsd %... | /berkus[P]grayzer/src/geom/Box.cpp |
render_scene(Scene*, double, double, int, int, char const*) | void render_scene(Scene* scene, double half_width, double half_height,
int nx, int ny,
char const* fname)
{
double x, y;
double hx = 2.0 * half_width / nx;
double hy = 2.0 * half_height / ny;
Ray ray;
Vector color;
int i, j;
auto tga = std::make_unique<Ta... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r12
movl %edx, %r13d
movl %esi, %ebp
movsd %xmm1, 0x10(%rsp)
movapd %xmm0, 0x20(%rsp)
movq %rdi, %r15
movl $0x40, %edi
callq 0x3120
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movl %ebp, 0xc(%rsp)
movl %ebp, %edx
movl %r1... | /berkus[P]grayzer/src/render/Render.cpp |
box_printf(char const*, ...) | void box_printf(char const* fmt, ...)
{
va_list marker;
char buffer[160]{0};
int len, i;
std::cerr << "║ ";
va_start(marker,fmt);
vsprintf(buffer,fmt,marker);
va_end(marker);
len = strlen(buffer);
for( i = len; i < 73; i++ )
buffer[i] = ' ';
std::cerr << buffer << "║\n... | pushq %r15
pushq %r14
pushq %rbx
subq $0x170, %rsp # imm = 0x170
movq %rdi, %rbx
leaq 0xc0(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x6c9b
movaps %xmm0, 0xf0(%rsp)
movaps %xmm1, 0x100(%rsp)
movaps %xmm2, 0x110(%rs... | /berkus[P]grayzer/src/Stats.cpp |
TargaImage::TargaImage(char const*, int, int, char*) | TargaImage::TargaImage( char const*name, int width, int height, char *comment )
{
FILE *fp = fopen(name, "w");
file = new FileDataSink(fp);
buf_size = 1000;
buffer = new rgb [buf_size];
pos = 0;
memset( &hdr, 0, sizeof(hdr) );
hdr.data_type = 2;
hdr.width = width;
hdr.height = he... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, 0x4(%rsp)
movl %edx, %r12d
movq %rsi, %rax
movq %rdi, %r14
leaq 0x4a98(%rip), %rcx # 0xbcc0
movq %rcx, (%rdi)
leaq 0x138b(%rip), %rsi # 0x85bd
movq %rax, %rdi
callq 0x3160
movq %rax, %r13
movl $0x10, %edi
ca... | /berkus[P]grayzer/src/image/Targa.cpp |
TargaImage::put_pixel(rgb) | void TargaImage::put_pixel( rgb color )
{
buffer[pos].r = color.b; // swap red & blue colors
buffer[pos].g = color.g;
buffer[pos].b = color.r;
if( ++pos >= buf_size ) flush();
} | pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl %esi, %ecx
shrl $0x10, %ecx
movq 0x28(%rdi), %rsi
movslq 0x34(%rdi), %rdx
leaq (%rdx,%rdx,2), %rdi
movb %cl, (%rsi,%rdi)
movb %ah, 0x1(%rsi,%rdi)
movb %al, 0x2(%rsi,%rdi)
leal 0x1(%rdx), %eax
movl %eax, 0x34(%rbx)
cmpl 0x30(%rbx), %eax
jl 0x73dd
movq 0x38(%rbx), %rdi
leal... | /berkus[P]grayzer/src/image/Targa.cpp |
higan::TcpServer::Start() | void TcpServer::Start()
{
thread_pool_.Start();
LOG_INFO << higan::Fmt("server: %s, listen on %s", server_name_.c_str(), server_addr_.GetIpPort().c_str());
acceptor_.Listen();
} | pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp # imm = 0x360
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x358(%rbp)
addq $0x8, %rdi
callq 0x457c0
callq 0x4e8b0
cmpl $0x1, %eax
jg 0x3d1b1
leaq 0x18329(%rip), %rdx # 0x553f1
leaq 0x1837f(%rip), %r8 # 0x5544e
leaq -0x220(%rbp), %rdi
movl $0x1... | /HiganFish[P]higan/higan/TcpServer.cpp |
higan::Socket::SetKeepALive() | void Socket::SetKeepALive()
{
int on = 1;
int result = setsockopt(fd_, SOL_SOCKET, SO_KEEPALIVE, static_cast<void*>(&on),
static_cast<socklen_t>(sizeof on));
if (result == -1)
{
LOG_FATAL << "set socket reuse port error";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, -0xc(%rbp)
movl (%rax), %edi
movl $0x1, %esi
movl $0x9, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x37690
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0x4ad0c
leaq 0xb03e(%rip), %rdx... | /HiganFish[P]higan/higan/Socket.cpp |
higan::Socket::SetReusePort() | void Socket::SetReusePort()
{
int on = 1;
int result = setsockopt(fd_, SOL_SOCKET, SO_REUSEPORT, static_cast<void*>(&on),
static_cast<socklen_t>(sizeof on));
if (result == -1)
{
LOG_FATAL << "set socket reuse port error";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, -0xc(%rbp)
movl (%rax), %edi
movl $0x1, %esi
movl $0xf, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x37690
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0x4b03c
leaq 0xad0e(%rip), %rdx... | /HiganFish[P]higan/higan/Socket.cpp |
convertFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void convertFile(const string& inputfilename, const string& outputfilename) {
MidiFile midifile(inputfilename);
for (int i=0; i<midifile.getTrackCount(); i++) {
for (int j=0; j<midifile.getEventCount(i); j++) {
if (!midifile[i][j].isNoteOff()) {
continue;
}
midifile[i]... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x13c04
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x16c2c
cmpl %eax, %ebp
jge 0xed52
xorl %r15d, %r15d
movq %r14, %rdi
movl %ebp, %esi
callq 0x189c4
cmpl %eax, %r15d
jge 0xed4e
movq %r14, ... | /dean-deng[P]midifile/src-programs/80off.cpp |
smf::Option_register::~Option_register() | Option_register::~Option_register() {
// do nothing
} | pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0xf0e6
callq 0xe2d0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0xf0f8
callq 0xe2d0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xf10a
callq 0xe2d0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx... | /dean-deng[P]midifile/src-library/Options.cpp |
smf::Options::Options() | Options::Options(void) {
m_oargc = -1;
m_suppressQ = 0;
m_processedQ = 0;
m_optionsArgument = 0;
m_options_error_check = 1;
m_optionFlag = '-';
m_extraArgv.reserve(100);
m_extraArgv_strings.reserve(100);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x30(%rdi), %rbx
movq %rbx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x48... | /dean-deng[P]midifile/src-library/Options.cpp |
smf::Options::Options(int, char**) | Options::Options(int argc, char** argv) {
m_oargc = -1;
m_suppressQ = 0;
m_processedQ = 0;
m_optionsArgument = 0;
m_options_error_check = 1;
m_optionFlag = '-';
m_extraArgv.reserve(100);
m_extraArgv_strings.reserve(100);
setOptions(argc, arg... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x30(%rdi), %r12
movq %r12, 0x20(%rdi)
movq %rax, 0x28(%rdi)... | /dean-deng[P]midifile/src-library/Options.cpp |
smf::Options::define(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | int Options::define(const std::string& aDefinition) {
Option_register* definitionEntry = NULL;
// Error if definition string doesn't contain an equals sign
auto location = aDefinition.find("=");
if (location == std::string::npos) {
std::cerr << "Error: no \"=\" in option definition: " << aDefinition ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x60(%rsp)
leaq 0x119ed(%rip), %rsi # 0x21234
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0xe530
cmpq $-0x1, %rax
je 0xfd8f
movq %rax, %r15
leaq 0xa8(%rsp), %rdi
movq %r14, %rsi
xo... | /dean-deng[P]midifile/src-library/Options.cpp |
smf::Options::getDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string Options::getDefinition(const std::string& optionName) {
auto it = m_optionList.find(optionName);
if (it == m_optionList.end()) {
return "";
} else {
return m_optionRegister[it->second]->getDefinition();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rsi), %rdi
movq %rdx, %rsi
callq 0x11abe
leaq 0x80(%r14), %rcx
cmpq %rcx, %rax
je 0xffa7
movslq 0x40(%rax), %rax
movq 0x60(%r14), %rcx
movq (%rcx,%rax,8), %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq ... | /dean-deng[P]midifile/src-library/Options.cpp |
smf::Options::getArg[abi:cxx11](int) | const std::string& Options::getArg(int index) {
if (index < 0 || index >= (int)m_argument.size()) {
std::cerr << "Error: m_argument " << index << " does not exist." << std::endl;
exit(1);
}
return m_argument[index];
} | pushq %rbx
movl %esi, %ebx
testl %esi, %esi
js 0x10021
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rcx
subq %rax, %rcx
shrq $0x5, %rcx
cmpl %ebx, %ecx
jle 0x10021
movl %ebx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
popq %rbx
retq
movq 0x1afc8(%rip), %rdi # 0x2aff0
leaq 0x112ae(%rip), %rsi # 0x212dd
callq 0xe300
movq %r... | /dean-deng[P]midifile/src-library/Options.cpp |
smf::MidiMessage::setTempoMicroseconds(int) | void MidiMessage::setTempoMicroseconds(int microseconds) {
resize(6);
(*this)[0] = 0xff;
(*this)[1] = 0x51;
(*this)[2] = 3;
(*this)[3] = (microseconds >> 16) & 0xff;
(*this)[4] = (microseconds >> 8) & 0xff;
(*this)[5] = (microseconds >> 0) & 0xff;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x6, %esi
callq 0x1955a
movq (%rbx), %rax
movb $-0x1, (%rax)
movq (%rbx), %rax
movb $0x51, 0x1(%rax)
movq (%rbx), %rax
movb $0x3, 0x2(%rax)
movl %ebp, %edx
movl %ebp, %eax
shrl $0x10, %eax
movq (%rbx), %rcx
movb %al, 0x3(%rcx)
movq (%rbx), %rax
movb... | /dean-deng[P]midifile/src-library/MidiMessage.cpp |
smf::MidiMessage::makeTimeSignature(int, int, int, int) | void MidiMessage::makeTimeSignature(int top, int bottom, int clocksPerClick,
int num32ndsPerQuarter) {
int base2 = 0;
while (bottom >>= 1) base2++;
resize(7);
(*this)[0] = 0xff;
(*this)[1] = 0x58;
(*this)[2] = 4;
(*this)[3] = 0xff & top;
(*this)[4] = 0xff & base2;
(*this)[5] = 0xff & clocksPerClick;
(*this)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %esi, %r15d
movq %rdi, %r14
xorl %r12d, %r12d
cmpl $0x2, %edx
jb 0x1b003
sarl %edx
incb %r12b
cmpl $0x1, %edx
ja 0x1aff9
movl $0x7, %esi
movq %r14, %rdi
callq 0x1955a
movq (%r14), %rax
movb $-0x1, (%rax)
movq (%r14), %rax
movb $... | /dean-deng[P]midifile/src-library/MidiMessage.cpp |
smf::MidiMessage::makeNoteOff(int, int) | void MidiMessage::makeNoteOff(int channel, int key) {
resize(3);
(*this)[0] = 0x90 | (0x0f & channel);
(*this)[1] = key & 0x7f;
(*this)[2] = 0x00;
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x3, %esi
callq 0x1955a
andb $0xf, %bpl
orb $-0x70, %bpl
movq (%r14), %rax
movb %bpl, (%rax)
andb $0x7f, %bl
movq (%r14), %rax
movb %bl, 0x1(%rax)
movq (%r14), %rax
movb $0x0, 0x2(%rax)
popq %rbx
popq %r14
popq %rbp
retq
| /dean-deng[P]midifile/src-library/MidiMessage.cpp |
smf::MidiMessage::makeNoteOff() | void MidiMessage::makeNoteOff(void) {
if (!isNoteOn()) {
resize(3);
(*this)[0] = 0x90;
(*this)[1] = 0;
(*this)[2] = 0;
} else {
(*this)[2] = 0;
}
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
cmpq $0x3, %rcx
jne 0x1b134
movb (%rax), %cl
andb $-0x10, %cl
cmpb $-0x70, %cl
jne 0x1b134
cmpb $0x0, 0x2(%rax)
jne 0x1b151
movl $0x3, %esi
movq %rbx, %rdi
callq 0x1955a
movq (%rbx), %rax
movb $-0x70, (%rax)
movq (%rbx), %rax
movb $0x0, 0... | /dean-deng[P]midifile/src-library/MidiMessage.cpp |
smf::MidiMessage::makeMetaMessage(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void MidiMessage::makeMetaMessage(int mnum, const std::string& data) {
resize(0);
push_back(0xff);
push_back(mnum & 0x7f); // max meta-message number is 0x7f.
setMetaContent(data);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %esi, %esi
callq 0x1955a
movb $-0x1, 0xf(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x1b2f7
movb $-0x1, (%rsi)
incq 0x8(%r14)
jmp 0x1b304
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1b3a4
andb $0x7f, %bpl
mo... | /dean-deng[P]midifile/src-library/MidiMessage.cpp |
smf::Binasc::writeToBinary(std::ostream&, std::istream&) | int Binasc::writeToBinary(std::ostream& out, std::istream& input) {
char inputLine[1024] = {0}; // current line being processed
int lineNum = 0; // current line number
input.getline(inputLine, 1024, '\n');
lineNum++;
while (!input.eof()) {
int status = processLine(out, inputLine, lineNum);
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
leaq 0x30(%rsp), %r12
movl $0x400, %edx # imm = 0x400
movq %r12, %rdi
xorl %esi, %esi
callq 0xe1d0
movl $0x400, %edx # imm = 0x400
mov... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::processLine(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::processLine(std::ostream& out, const std::string& input,
int lineCount) {
int status = 1;
int i = 0;
int length = (int)input.size();
std::string word;
while (i<length) {
if ((input[i] == ';') || (input[i] == '#') || (input[i] == '/')) {
// comment to end of line, so ignore
return 1;
} else ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x4(%rsp)
movl 0x8(%rdx), %ebp
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl $0x1, %ebx
testl %ebp, %ebp
jle 0x1bdfc
movq %rdx, %r14
movq %rsi, %r15
xorl %ebx, %ebx
leaq 0x8(%rsp), %... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::readFromBinary(std::ostream&, std::istream&) | int Binasc::readFromBinary(std::ostream& out, std::istream& input) {
int status;
if (m_midiQ) {
status = outputStyleMidi(out, input);
} else if (!m_bytesQ) {
status = outputStyleAscii(out, input);
} else if (m_bytesQ && m_commentsQ) {
status = outputStyleBoth(out, input);
} else {
status = outputStyleBinar... | pushq %rax
cmpl $0x0, 0x8(%rdi)
je 0x1c06b
popq %rax
jmp 0x1c2aa
cmpl $0x0, (%rdi)
je 0x1c07d
cmpl $0x0, 0x4(%rdi)
je 0x1c089
callq 0x1cece
jmp 0x1c082
callq 0x1cd04
movl $0x1, %eax
popq %rcx
retq
popq %rax
jmp 0x1d0f6
nop
| /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::readFromBinary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::istream&) | int Binasc::readFromBinary(const std::string& outfile, std::istream& input) {
std::ofstream output;
output.open(outfile.c_str());
if (!output.is_open()) {
std::cerr << "Cannot open " << outfile
<< " for reading in binasc." << std::endl;
return 0;
}
int status = readFromBinary(output, input);
outp... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xe510
movq (%rbx), %rsi
movq %r12, %rdi
movl $0x10, %edx
callq 0xe060
leaq 0x78(%rsp), %rdi
callq 0xe0c0
testb %al, %al
je 0x1c0f0
leaq 0x8(%... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::outputStyleBinary(std::ostream&, std::istream&) | int Binasc::outputStyleBinary(std::ostream& out, std::istream& input) {
int currentByte = 0; // current byte output in line
uchar ch; // current input byte
ch = input.get();
if (input.eof()) {
std::cerr << "End of the file right away!" << std::endl;
return 0;
}
while (!input.eof()) {
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0xe380
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%r14,%rcx)
jne 0x1d1e3
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
movl $0x1, %r12d
testb $0x2, 0x20(%r14,%rcx)... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::getWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::getWord(std::string& word, const std::string& input,
const std::string& terminators, int index) {
word.resize(0);
int i = index;
int escape = 0;
int ecount = 0;
if (terminators.find('"') != std::string::npos) {
escape = 1;
}
while (i < (int)input.size()) {
if (escape && input[i] == '\"') {
e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdi
xorl %ebp, %ebp
movq %rsi, 0x10(%rsp)
xorl %esi, %esi
xorl %edx, %edx
callq 0xe110
movq %r14, 0x8(%rsp)
movq %r14, %rdi
movl $0x22, %esi
xorl %edx, %edx
callq 0xe3f0
movq %r... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::processBinaryWord(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | int Binasc::processBinaryWord(std::ostream& out, const std::string& word,
int lineNum) {
int length = (int)word.size(); // length of ascii binary number
int commaIndex = -1; // index location of comma in number
int leftDigits = -1; // number of digits to left of comma
int rightDigit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq 0x8(%rdx), %rcx
testl %ecx, %ecx
jle 0x1e627
movq (%rbx), %rdx
movl %ecx, %edi
andl $0x7fffffff, %edi # imm = 0x7FFFFFFF
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movzbl (%rdx,%r12)... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::writeBigEndianLong(std::ostream&, long) | std::ostream& Binasc::writeBigEndianLong(std::ostream& out, long value) {
union { char bytes[4]; long l; } data;
data.l = value;
out << data.bytes[3];
out << data.bytes[2];
out << data.bytes[1];
out << data.bytes[0];
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, %ebp
shrl $0x10, %ebp
movl %esi, %eax
movq %rsi, %r14
shrl $0x18, %eax
leaq 0xd(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0xe360
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0xe360
movq %r14, %rax
movb ... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::Binasc::writeLittleEndianULong(std::ostream&, unsigned long) | std::ostream& Binasc::writeLittleEndianULong(std::ostream& out, ulong value) {
union { char bytes[4]; ulong ul; } data;
data.ul = value;
out << data.bytes[0];
out << data.bytes[1];
out << data.bytes[2];
out << data.bytes[3];
return out;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %ebx, %r15d
shrl $0x10, %r15d
movl %ebx, %ebp
shrl $0x18, %ebp
leaq 0x5(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
callq 0xe360
movb %bh, 0x4(%rsp)
leaq 0x4(%rsp), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0xe360
leaq 0x6(%rs... | /dean-deng[P]midifile/src-library/Binasc.cpp |
smf::MidiEvent::~MidiEvent() | MidiEvent::~MidiEvent() {
track = -1;
tick = -1;
seconds = -1.0;
seq = -1;
this->resize(0);
m_eventlink = NULL;
} | pushq %rbx
movq %rdi, %rbx
movq $-0x1, 0x18(%rdi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x20(%rdi)
movl $0xffffffff, 0x28(%rdi) # imm = 0xFFFFFFFF
xorl %esi, %esi
callq 0x1955a
movq $0x0, 0x30(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x19f22
movq %rax, %rdi
callq 0x11239
nop
| /dean-deng[P]midifile/src-library/MidiEvent.cpp |
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 0x17cfe
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movap... | /Konf[P]LearnOpenGL-CLion/glfw/src/init.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 0x1855c
leaq 0x3b39d(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x18522
movl %esi, %edx
leal -0x33001(%rdx), %eax
cmpl $0x3, %eax
ja 0x18543
leaq 0x2e198(%rip), %rcx # 0x466ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x74(%rdi), %ebx
jmp 0x18558
xorl %ebx, %ebx
m... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwJoystickIsGamepad | GLFWAPI int glfwJoystickIsGamepad(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
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 0x19f5b
cmpl $0x10, %edi
jae 0x19f7a
leaq 0x3999a(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x19f3d
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x400(%rax,%rcx)
je 0x19f4f
leaq (%rax,%rcx), %r14
addq $0x400, %r14 # imm = 0x... | /Konf[P]LearnOpenGL-CLion/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 %rbx
testl %edi, %edi
js 0x1a23f
cmpl $0x10, %edi
jae 0x1a25e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a27d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x3981a(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1a225
movl %edi, %ecx
imulq $0x1fa0, ... | /Konf[P]LearnOpenGL-CLion/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 0x394fb(%rip), %r14 # 0x53898
cmpl $0x0, (%r14)
je 0x1a428
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1a43d
ucomisd 0x2c3e3(%rip), %xmm0 # 0x467a0
ja 0x1a43d
movsd %xmm0, (%rsp)
callq 0x24401
movq %rax, %rbx
callq 0x2444d
movq %rax, %xmm0
punpckldq 0x2c392(%rip), %xmm0 # x... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
isValidElementForJoystick | static GLFWbool isValidElementForJoystick(const _GLFWmapelement* e,
const _GLFWjoystick* js)
{
if (e->type == _GLFW_JOYSTICK_HATBIT && (e->index >> 4) >= js->hatCount)
return GLFW_FALSE;
else if (e->type == _GLFW_JOYSTICK_BUTTON && e->index >= js->buttonCount)
... | movzbl (%rdi), %eax
cmpl $0x1, %eax
je 0x1a4cc
cmpl $0x2, %eax
je 0x1a4bd
cmpl $0x3, %eax
jne 0x1a4c6
movzbl 0x1(%rdi), %eax
shrl $0x4, %eax
cmpl %eax, 0x30(%rsi)
jg 0x1a4c6
jmp 0x1a4d5
movzbl 0x1(%rdi), %eax
cmpl %eax, 0x20(%rsi)
jle 0x1a4d5
movl $0x1, %eax
retq
movzbl 0x1(%rdi), %eax
cmpl %eax, 0x10(%rsi)
jg 0x1a4c6
... | /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 0x1a945
movl 0x4(%rdi), %eax
imull (%rdi), %eax
movl 0x4(%rsi), %ecx
imull (%rsi), %ecx
subl %ecx, %eax
jne 0x1a945
movl 0x14(%rdi), %eax
subl 0x14(%rsi), %eax
retq
| /Konf[P]LearnOpenGL-CLion/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 0x1a9bf
movl $0x0, (%rdi)
leaq 0x38f04(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1a9aa
movl 0x3f8(%rax), %ecx
movl %ecx, (%rdi)
movq 0x3f0(%rax), %rbx
jmp 0x1a9ba
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x17c9f
movq %rbx, %... | /Konf[P]LearnOpenGL-CLion/glfw/src/monitor.c |
glfwGetMonitorPhysicalSize | GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int* heightMM)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (widthMM)
*widthMM = 0;
if (heightMM)
*heightMM = 0;
_GLFW_REQUIRE_INIT();
if (widthMM)
*widthMM = mo... | testq %rdi, %rdi
je 0x1aabd
testq %rsi, %rsi
je 0x1aa83
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1aa8e
movl $0x0, (%rdx)
leaq 0x38e03(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1aaaf
testq %rsi, %rsi
je 0x1aaa4
movl 0x10(%rdi), %eax
movl %eax, (%rsi)
testq %rdx, %rdx
je 0x1aaae
movl 0x14(%rdi), %eax
movl %eax, (%r... | /Konf[P]LearnOpenGL-CLion/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 0x1ab17
testq %rsi, %rsi
je 0x1aaed
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1aaf8
movl $0x0, (%rdx)
leaq 0x38d99(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1ab09
jmp 0x1fa2b
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x17c9f
pushq %rax
leaq 0x2c548(%rip), ... | /Konf[P]LearnOpenGL-CLion/glfw/src/monitor.c |
glfwSetGammaRamp | GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(ramp != NULL);
assert(ramp->size > 0);
assert(ramp->red != NULL);
assert(ramp->green != NULL);
assert(ramp->blue != NULL);
if (... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1af5f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1af7e
cmpl $0x0, 0x18(%rbx)
je 0x1af9d
cmpq $0x0, (%rbx)
je 0x1afbc
cmpq $0x0, 0x8(%rbx)
je 0x1afdb
cmpq $0x0, 0x10(%rbx)
je 0x1affa
leaq 0x3897a(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1af4a
movq %rdi, %r14
cmpl... | /Konf[P]LearnOpenGL-CLion/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 0x1b4fb
leaq 0x383ff(%rip), %r15 # 0x53898
cmpl $0x0, (%r15)
je 0x1b4dc
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %edi
callq 0x1b084
testl %eax, %eax
je 0x1b4ef
movq %r14, %rdi
movq %rbx, %rsi
callq *0x1fe90(%r15)
movq %rax, %r14
testq %rax, %rax
jne 0x1b4f2
mov... | /Konf[P]LearnOpenGL-CLion/glfw/src/vulkan.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 0x1be52
leaq 0x37aaa(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1be14
movl %edi, %edx
cmpl $0x24002, %edi # imm = 0x24002
je 0x1be29
cmpl $0x24001, %edx # imm = 0x24001
je 0x1be22
cmpl $0x23002, %edx # imm = 0x23002
jne 0x1be3f
movl $0x94, %edi
jmp 0x1be2e
movl $0x10... | /Konf[P]LearnOpenGL-CLion/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 0x1c083
leaq 0x37834(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1c075
cmpq $0x0, 0x40(%rdi)
je 0x213ba
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x17c9f
pushq %rax
leaq 0xf070(%rip), %rdi # 0x2b0fb
leaq 0x2bccc(%rip), %rsi # 0x47d5e
leaq 0x2... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwSetWindowAspectRatio | GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(numer != 0);
assert(denom != 0);
_GLFW_REQUIRE_INIT();
if (numer != GLFW_DONT_CARE && denom != GLFW_DONT_CARE)
{
if (numer <... | pushq %rax
testq %rdi, %rdi
je 0x1c2f3
movl %edx, %ecx
movl %esi, %edx
testl %esi, %esi
je 0x1c312
testl %ecx, %ecx
je 0x1c331
leaq 0x3760f(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1c2d4
cmpl $-0x1, %edx
sete %al
cmpl $-0x1, %ecx
sete %sil
orb %al, %sil
jne 0x1c2c5
testl %edx, %edx
setg %al
testl %ecx, %ecx
set... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwSetWindowAttrib | GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
value = value ? GLFW_TRUE : GLFW_FALSE;
if (attrib == GLFW_AUTO_ICONIFY)
window->autoIconify = value;
else if (attri... | testq %rdi, %rdi
je 0x1c988
leaq 0x36fa0(%rip), %rcx # 0x53898
cmpl $0x0, (%rcx)
je 0x1c938
movl %esi, %eax
xorl %esi, %esi
testl %edx, %edx
setne %dl
leal -0x20003(%rax), %ecx
cmpl $0x4, %ecx
ja 0x1c96e
movb %dl, %sil
leaq 0x2b421(%rip), %rdx # 0x47d3c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl... | /Konf[P]LearnOpenGL-CLion/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 0x369ce(%rip), %rax # 0x53898
cmpl $0x0, (%rax)
je 0x1cf0b
ucomisd %xmm0, %xmm0
jp 0x1cf20
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1cf3f
movsd 0x298a9(%rip), %xmm1 # 0x46790
ucomisd %xmm0, %xmm1
jb 0x1cf5e
ucomisd 0x2989b(%rip), %xmm0 # 0x46790
jbe 0x1cf1a
leaq 0x29fdb(%rip), %rsi # 0... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwPlatformGetVersionString | const char* _glfwPlatformGetVersionString(void)
{
return _GLFW_VERSION_NUMBER " X11 GLX EGL"
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
" clock_gettime"
#else
" gettimeofday"
#endif
#if defined(__linux__)
" evdev"
#endif
#if defined(_GLFW_BUILD_DLL)
" shared"
#endi... | leaq 0x29b19(%rip), %rax # 0x48d37
retq
nop
| /Konf[P]LearnOpenGL-CLion/glfw/src/x11_init.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
{
... | movq %rdi, %rcx
cmpw $0x8, %dx
je 0x1f808
movzwl %dx, %eax
cmpl $0x2, %eax
jne 0x1f813
leaq 0xc(%rsi), %rax
movl $0x8, %edx
jmp 0x1f81c
leaq 0x8(%rsi), %rax
movl $0xc, %edx
movl (%rax), %eax
movl %eax, (%rcx)
movl (%rsi,%rdx), %eax
movl %eax, 0x4(%rcx)
movl 0x20(%rsi), %eax
xorl %edi, %edi
testl %eax, %eax
je 0x1f873
m... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_monitor.c |
glfwPlatformGetMonitorPos | void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_g... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x33efd(%rip), %rax # 0x53898
cmpl $0x0, 0x20558(%rax)
je 0x1fa21
cmpl $0x0, 0x2057c(%rax)
jne 0x1fa21
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x1feb8(%rax), %rdi
movq 0x1fec8(%rax), %rsi
movq %rax, %r13
callq *0x205d0(%rax)
movq %rax, %r15
mo... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_monitor.c |
handleSelectionRequest | static void handleSelectionRequest(XEvent* event)
{
const XSelectionRequestEvent* request = &event->xselectionrequest;
XEvent reply;
memset(&reply, 0, sizeof(reply));
reply.xselection.property = writeTargetToProperty(request);
reply.xselection.type = SelectionNotify;
reply.xselection.display =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rdi, %rbp
leaq 0x68(%rsp), %rdi
xorl %r14d, %r14d
movl $0xc0, %edx
xorl %esi, %esi
callq 0x130d0
leaq 0x33803(%rip), %r13 # 0x53898
movq 0x30(%rbp), %rcx
movq 0x40(%rbp), %r15
xorl %eax, %eax
cmpq 0x20... | /Konf[P]LearnOpenGL-CLion/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 0x328e7(%rip), %r14 # 0x53898
cmpq %rdi, 0x203e0(%r14)
jne 0x20fc5
movq $0x0, 0x203e0(%r14)
cmpq $0x0, 0x40(%rbx)
je 0x20fd4
movq %rbx, %rdi
callq 0x21087
movq 0x348(%rbx), %rdi
testq %rdi, %rdi
je 0x20ff0
callq 0x135d0
movq $0x0, 0x348(%rbx)
movq 0x260(%rbx), %... | /Konf[P]LearnOpenGL-CLion/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 0x32532(%rip), %rax # 0x53898
movq 0x340(%rdi), %rsi
movq 0x1feb8(%rax), %rdi
movq 0x1fec8(%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 0x132d0
addq $... | /Konf[P]LearnOpenGL-CLion/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 $0x90, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x324c1(%rip), %r12 # 0x53898
movq 0x1feb8(%r12), %rdi
movq 0x340(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x13810
cmpl $0x2, 0x5c(%r15)
je 0x2144d
callq 0x13850
movq %rax, %r15... | /Konf[P]LearnOpenGL-CLion/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 0x40(%rdi), %rax
testq %rax, %rax
je 0x21533
cmpq %r14, 0x18(%rax)
jne 0x21568
movq %r14, %rdi
callq 0x20eba
jmp 0x21568
movl %edx, %ebx
movl %esi, %ebp
cmpl $0x0, 0x8(%r14)
jne 0x2154a
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x2157f
leaq 0x32347(%rip)... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetWindowSizeLimits | void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
int minwidth, int minheight,
int maxwidth, int maxheight)
{
int width, height;
_glfwPlatformGetWindowSize(window, &width, &height);
updateNormalHints(window, width, height);... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x32212(%rip), %r15 # 0x53898
movq 0x1feb8(%r15), %rdi
movq 0x340(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x13810
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0x2157f
movq 0x1feb8(%r15), %rdi
callq 0x135f0
addq ... | /Konf[P]LearnOpenGL-CLion/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 0x21940
cmpl $0x0, 0x38(%rsi)
je 0x21941
retq
movq 0x20(%rsi), %rcx
cmpq 0x340(%rdx), %rcx
jne 0x21940
movq 0x28(%rsi), %rcx
leaq 0x31f3f(%rip), %rdx # 0x53898
xorl %eax, %eax
cmpq 0x20490(%rdx), %rcx
sete %al
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformIconifyWindow | void _glfwPlatformIconifyWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification ... | cmpl $0x0, 0x350(%rdi)
je 0x219b3
leaq 0x27c72(%rip), %rsi # 0x49619
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x17c9f
pushq %rbx
leaq 0x31edd(%rip), %rbx # 0x53898
movq 0x1feb8(%rbx), %rax
movq 0x340(%rdi), %rsi
movl 0x1fec0(%rbx), %edx
movq %rax, %rdi
callq 0x132b0
movq 0x1feb8(%rbx), %... | /Konf[P]LearnOpenGL-CLion/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)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x31ccc(%rip), %r14 # 0x53898
movq 0x20438(%r14), %r12
movq 0x20450(%r14), %r15
testq %r12, %r12
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
movq 0x20458(%r14), %r13
testq %r13, %r13
setne %al
andb %cl, %al
cmpb $0x1, %al... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.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 0x21e94
testq %rax, %rax
je 0x21e3d
movq %rbx, %rdi
callq 0x21087
movq %rbx, %rdi
movq %r13, %rsi
callq... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
getWindowState | static int getWindowState(_GLFWwindow* window)
{
int result = WithdrawnState;
struct {
CARD32 state;
Window icon;
} *state = NULL;
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.WM_STATE,
_glfw.x11.WM_STATE... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
leaq 0x31915(%rip), %rax # 0x53898
movq 0x203f0(%rax), %rdx
movq 0x1feb8(%rax), %rdi
leaq 0x18(%rsp), %rax
leaq 0x20(%rsp), %r15
leaq 0xc(%rsp), %r10
leaq 0x28(%rsp), %r11
xorl %ebx, %ebx
movabsq $0x7ffffffffff... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformWindowMaximized | int _glfwPlatformWindowMaximized(_GLFWwindow* window)
{
Atom* states;
unsigned long i;
GLFWbool maximized = GLFW_FALSE;
const unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x340(%rdi), %rsi
leaq 0x31893(%rip), %r14 # 0x53898
movq 0x20438(%r14), %rdx
movq 0x1feb8(%r14), %rdi
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rax
leaq 0x18(%rsp), %r12
leaq 0x4(%rsp), %r10
leaq 0x20(%rsp), %r11
xorl %ebx, %ebx
movabsq $0x7fffffffffff... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetWindowDecorated | void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
{
if (enabled)
{
XDeleteProperty(_glfw.x11.display,
window->x11.handle,
_glfw.x11.MOTIF_WM_HINTS);
}
else
{
struct
{
unsigned long flags;
... | testl %esi, %esi
je 0x221e7
leaq 0x316ce(%rip), %rcx # 0x53898
movq 0x1feb8(%rcx), %rax
movq 0x340(%rdi), %rsi
movq 0x204a0(%rcx), %rdx
movq %rax, %rdi
jmp 0x133b0
subq $0x28, %rsp
movq %rsp, %r10
movq $0x2, (%r10)
movq $0x0, 0x10(%r10)
leaq 0x31694(%rip), %rcx # 0x53898
movq 0x1feb8(%rcx), %rax
movq 0x340(%rdi... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformCreateTls | GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
{
assert(tls->posix.allocated == GLFW_FALSE);
if (pthread_key_create(&tls->posix.key, NULL) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"POSIX: Failed to create context TLS");
return GLFW_FALSE;
}
tls->posix.al... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jne 0x244a4
movq %rdi, %r14
addq $0x4, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x13470
testl %eax, %eax
je 0x2448e
leaq 0x262f2(%rip), %rsi # 0x4a772
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x17c9f
jmp 0x2449a
movl $0x1, (%r14)
movl $0... | /Konf[P]LearnOpenGL-CLion/glfw/src/posix_thread.c |
glfwInitGLX | GLFWbool _glfwInitGLX(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_GLX_LIBRARY)
_GLFW_GLX_LIBRARY,
#elif defined(__CYGWIN__)
"libGL-1.so",
#else
"libGL.so.1",
"libGL.so",
#endif
NULL
};
if (_glfw.glx.handle)
return GLFW_TRUE;
for (i... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x2f270(%rip), %r14 # 0x53898
movl $0x1, %ebx
cmpq $0x0, 0x20768(%r14)
jne 0x24943
xorl %ebx, %ebx
leaq 0x2c70c(%rip), %r15 # 0x50d50
movq (%rbx,%r15), %rdi
movl $0x1, %esi
callq 0x13500
movq %rax, 0x20768(%r14)
testq %rax, %rax
jne 0x2467b
addq $0x8, %rbx
cmpq $0x10, %rbx
... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
swapIntervalGLX | static void swapIntervalGLX(int interval)
{
_GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (_glfw.glx.EXT_swap_control)
{
_glfw.glx.SwapIntervalEXT(_glfw.x11.display,
window->context.glx.window,
interval);
}
... | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x2e43f(%rip), %r14 # 0x53898
leaq 0x1fe14(%r14), %rdi
callq 0x244dd
movq %r14, %rdx
cmpl $0x0, 0x2080c(%r14)
je 0x25492
movq 0x207f0(%rdx), %rcx
movq 0x1feb8(%rdx), %rdi
movq 0x270(%rax), %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
cmpl ... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
glfwTerminateEGL | void _glfwTerminateEGL(void)
{
if (_glfw.egl.display)
{
eglTerminate(_glfw.egl.display);
_glfw.egl.display = EGL_NO_DISPLAY;
}
if (_glfw.egl.handle)
{
_glfw_dlclose(_glfw.egl.handle);
_glfw.egl.handle = NULL;
}
} | pushq %rbx
leaq 0x2de77(%rip), %rbx # 0x53898
movq 0x20888(%rbx), %rdi
testq %rdi, %rdi
je 0x25a3e
callq *0x208e0(%rbx)
movq $0x0, 0x20888(%rbx)
movq 0x208b0(%rbx), %rdi
testq %rdi, %rdi
je 0x25a5a
callq 0x139c0
movq $0x0, 0x208b0(%rbx)
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
Gudhi::Persistence_representations::read_persistence_intervals_in_one_dimension_from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, double) | std::vector<std::pair<double, double> > read_persistence_intervals_in_one_dimension_from_file(
std::string const& filename, int dimension = -1, double what_to_substitute_for_infinite_bar = -1) {
bool dbg = false;
std::string line;
std::vector<std::pair<double, double> > barcode_initial =
read_persisten... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movsd %xmm0, 0x28(%rsp)
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %ecx, %ecx
movq %rcx, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rax)
movq %rsi, %rdi
movl %e... | /GUDHI[P]gudhi-devel/src/Persistence_representations/include/gudhi/read_persistence_from_file.h |
Gudhi::Persistence_representations::Persistence_landscape_on_grid::Persistence_landscape_on_grid(char const*, unsigned long, unsigned short) | Persistence_landscape_on_grid::Persistence_landscape_on_grid(const char* filename, size_t number_of_points_,
uint16_t dimension) {
std::vector<std::pair<double, double> > p;
if (dimension == std::numeric_limits<uint16_t>::max()) {
p = read_persistence... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq %rax, 0x40(%rsp)
movapd %xmm0, 0x30(%rsp)
cmpl $0xffff, %ecx # imm = 0xFFFF
je 0x4b24
movl %ecx, %ebp
leaq 0... | /GUDHI[P]gudhi-devel/src/Persistence_representations/include/gudhi/Persistence_landscape_on_grid.h |
check_construction_of_landscape::test_method() | BOOST_AUTO_TEST_CASE(check_construction_of_landscape) {
Persistence_landscape_on_grid l("data/file_with_diagram_1", 100, std::numeric_limits<unsigned short>::max());
l.print_to_file("landscape_from_file_with_diagram_1");
Persistence_landscape_on_grid g;
g.load_landscape_from_file("landscape_from_file_with_diag... | pushq %r14
pushq %rbx
subq $0xf8, %rsp
leaq 0xa042(%rip), %rsi # 0x1044f
leaq 0x60(%rsp), %rbx
movl $0x64, %edx
movq %rbx, %rdi
movl $0xffff, %ecx # imm = 0xFFFF
callq 0x4ac2
leaq 0xa03d(%rip), %rsi # 0x10468
movq %rbx, %rdi
callq 0x5150
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, 0x20(%r... | /GUDHI[P]gudhi-devel/src/Persistence_representations/test/persistence_lanscapes_on_grid_test.cpp |
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.