name string | code string | asm string | file string |
|---|---|---|---|
graph_5_4::bfs_2(graph_5_4::m_graph) | int bfs_2(m_graph g) {
for (int i = 0; i < g.vnum; i++)
visited[i] = 0;
// InitQueue(Q);
// for (int j = 0; j < g.vnum; j++) {
// if (visited[j] == 0) {
// visited[j] = 1;
// visit;
// EnQueue(Q, j);
// while (!isEm... | leaq 0x3d43(%rip), %rax # 0x7140
andl $0x0, (%rax)
addq $0x4, %rax
jmp 0x33fd
| /baiyuu[P]c_datastruct/d_5/r4.h |
libchars::command_cursor::command(unsigned long, bool) const | bool command_cursor::command(command::filter_t mask, bool ignore_hidden) const
{
return valid() &&
(current()->mask & mask) != 0 &&
(!current()->hidden || ignore_hidden) &&
current()->cmd != NULL &&
(current()->cmd->mask & mask) != 0 &&
... | pushq %rbp
movq %rsp, %rbp
movq 0x30(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0xae96
movq 0x38(%rdi), %rcx
cmpq %rcx, %rax
je 0xaeda
cmpq $0x0, -0x8(%rax)
je 0xafa9
movq -0x8(%rax), %r8
testq %rsi, 0x20(%r8)
je 0xafa9
movq -0x8(%rax), %r8
movb 0x28(%r8), %r8b
xorb $0x1, %r8b
orb %dl, %r8b
jne 0xaf2e
jmp 0xafa9
movq 0x70(%r... | /roelfdutoit[P]libchars/commands.cpp |
libchars::commands::find_pval(libchars::token*) | token *commands::find_pval(token *position)
{
if (cmd == NULL)
return NULL;
token *T = (position == NULL) ? t_par : position->next;
while (T != NULL && T->ttype != token::VALUE)
T = T->next;
return T;
} | cmpq $0x0, 0x4170(%rdi)
je 0xdb96
pushq %rbp
movq %rsp, %rbp
addq $0x4168, %rdi # imm = 0x4168
leaq 0x88(%rsi), %rax
testq %rsi, %rsi
cmoveq %rdi, %rax
movq (%rax), %rax
testq %rax, %rax
je 0xdb92
cmpl $0x3, 0x40(%rax)
je 0xdb94
movq 0x88(%rax), %rax
jmp 0xdb7e
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
r... | /roelfdutoit[P]libchars/commands.cpp |
libchars::commands::deactivate_all_sets() | void commands::deactivate_all_sets()
{
//NOTE: C_set_default not deactivated
command_sets_t::iterator csi = C_sets.begin();
while (csi != C_sets.end()) {
command_set &C_set = csi->second;
C_set.deactivate();
++csi;
}
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40c8(%rdi), %rax
addq $0x40b8, %rbx # imm = 0x40B8
cmpq %rbx, %rax
je 0xdcbc
cmpb $0x1, 0x48(%rax)
jne 0xdcb2
movw $0x100, 0x48(%rax) # imm = 0x100
movq %rax, %rdi
callq 0x9480
jmp 0xdca1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| /roelfdutoit[P]libchars/commands.cpp |
libchars::commands::add_commands_from_set(libchars::command_set&) | void commands::add_commands_from_set(command_set &C_set)
{
LC_LOG_VERBOSE("set[%p] root[%p]",&C_set,&root);
command *C_list = C_set.get();
while (C_list != NULL) {
command *cmd = C_list;
C_list = C_list->next;
// break command string into tokens
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorl %edi, %edi
callq 0x9370
movq %rbx, -0x38(%rbp)
leaq 0x40f0(%rbx), %r14
leaq 0x703c(%rip), %rdx # 0x15172
leaq 0x7542(%rip), %r8 # 0x1567f
leaq 0x7551(%rip), %r9 # 0x15... | /roelfdutoit[P]libchars/commands.cpp |
libchars::commands::run(unsigned long) | commands::status_t commands::run(command::filter_t mask_)
{
build_commands();
if (this->prompt.empty())
this->prompt = ">";
this->mask = mask_;
if (!edit.interactive()) {
parse();
return status;
}
else {
// reset command struc... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9390
cmpq $0x0, 0x4020(%rbx)
jne 0xe317
leaq 0x4018(%rbx), %rdi
leaq 0x708b(%rip), %rcx # 0x15393
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x9ae0
movq %r14, 0x4148... | /roelfdutoit[P]libchars/commands.cpp |
libchars::edit_object::emptied() | virtual void set(const char *line, size_t idx = std::string::npos)
{
if (line != NULL) {
size_t L = buflen;
strncpy(buffer,line,sizeof(buffer)-1);
buffer[sizeof(buffer) - 1] = 0;
buflen = strlen(buffer);
if (idx <= bufl... | pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
| /roelfdutoit[P]libchars/editor.h |
libchars::edit_object::insert(char) | virtual void insert(const char c)
{
if (buflen < (MAX_LINE-1)) {
if (insert_idx < buflen) {
memmove(buffer+insert_idx+1, buffer+insert_idx, buflen-insert_idx);
}
volatile char *p = buffer + insert_idx;
*p = c;
... | movq 0x4008(%rdi), %rdx
cmpq $0x3ffe, %rdx # imm = 0x3FFE
ja 0xebfc
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x4038(%rdi), %rax
subq %rax, %rdx
jbe 0xebe5
leaq (%rbx,%rax), %rsi
addq $0x8, %rsi
leaq (%rbx,%rax), %rdi
addq $0x9, %rdi
callq 0x9b60
movq 0x4038(%rbx),... | /roelfdutoit[P]libchars/editor.h |
libchars::edit_object::wipe() | virtual void wipe()
{
if (buflen > insert_idx) {
volatile char *p = buffer + buflen - 1;
while (buflen > insert_idx) {
*p-- = 0;
--buflen;
}
if (buflen == 0)
emptied();
... | pushq %rbp
movq %rsp, %rbp
movq 0x4008(%rdi), %rax
cmpq 0x4038(%rdi), %rax
jbe 0xec3e
addq %rdi, %rax
addq $0x7, %rax
movb $0x0, (%rax)
movq 0x4008(%rdi), %rcx
decq %rcx
movq %rcx, 0x4008(%rdi)
decq %rax
cmpq 0x4038(%rdi), %rcx
ja 0xec19
testq %rcx, %rcx
je 0xec40
popq %rbp
retq
movq (%rdi), %rax
popq %rbp
jmpq *0x10(%... | /roelfdutoit[P]libchars/editor.h |
libchars::edit_object::del() | virtual void del()
{
size_t L = buflen;
if (insert_idx < buflen) {
if (insert_idx < (buflen-1)) {
memmove(buffer+insert_idx, buffer+insert_idx+1, buflen-1-insert_idx);
}
volatile char *p = buffer + buflen - 1;
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4008(%rdi), %r14
movq 0x4038(%rdi), %rax
movq %r14, %rcx
cmpq %r14, %rax
jae 0xeca6
leaq -0x1(%r14), %rdx
movq %r14, %rcx
subq %rax, %rdx
jbe 0xec90
leaq (%rbx,%rax), %rdi
addq $0x8, %rdi
leaq (%rbx,%rax), %rsi
addq $0x9, %rsi
callq 0x9b60
movq 0x4... | /roelfdutoit[P]libchars/editor.h |
libchars::command::~command() | ~command() { delete next; } | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %r14
testq %r14, %r14
je 0xedb8
movq %r14, %rdi
callq 0x99f0
movl $0x98, %esi
movq %r14, %rdi
callq 0x9670
leaq 0x68(%rbx), %rdi
callq 0x9950
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0xede6
movq (%rax), %rsi
incq %rs... | /roelfdutoit[P]libchars/commands.h |
libchars::debug::~debug() | debug::~debug()
{
if (_d_ != NULL) {
fclose(_d_);
_d_ = NULL;
}
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb788(%rip), %rdi # 0x1b8f8
testq %rdi, %rdi
je 0x10185
callq 0x9640
movq $0x0, 0xb773(%rip) # 0x1b8f8
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x101a3
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9670
a... | /roelfdutoit[P]libchars/debug.cpp |
libchars::debug::log(unsigned int, char const*, unsigned int, char const*, char const*, ...) | void debug::log(unsigned int lvl, const char *file, unsigned int line, const char *function, const char *format, ...)
{
if (lvl <= log_level) {
if (!initialized) {
initialize__();
}
if (_d_ != NULL) {
static __thread char buffer[8192];
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
testb %al, %al
je 0x101f1
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7,... | /roelfdutoit[P]libchars/debug.cpp |
libchars::editor::decode_key(unsigned char) | key_e editor::decode_key(uint8_t c)
{
if (seq_N < MAX_DECODE_SEQUENCE) {
seq[seq_N++] = c;
size_t idx;
for (idx = 0; idx < DECODE_TABLE_ENTRIES; ++idx) {
const char *T_seq = __decode_table[idx].sequence;
size_t T_seq_N = strlen(T_seq);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %esi, %r14d
movq %rdi, %rbx
movq 0x28(%rdi), %r15
cmpq $0xf, %r15
ja 0x10381
leaq 0x18(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq 0x1(%r15), %rax
movq %rax, 0x28(%rbx)
movb %r14b, 0x18(%rbx,%r1... | /roelfdutoit[P]libchars/editor.cpp |
libchars::editor::render(unsigned long, unsigned long) | size_t editor::render(size_t buf_idx, size_t length)
{
std::string sequence;
size_t n = obj->render(obj->idx(buf_idx),length,sequence);
if (n > 0)
driver.write(sequence.data(),sequence.length());
return n;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x8(%rdi), %rdi
movq 0x4008(%rdi), %rax
cmpq %rsi, %rax
cmovbq %rax, %rsi
movq (%rdi), %rax
leaq -0x38(%rbp), %rcx
callq *0x58(%rax)
mov... | /roelfdutoit[P]libchars/editor.cpp |
libchars::terminal_driver::terminal_driver() | terminal_driver::terminal_driver() :
T_must_return_ms(0),
is_tty(true),
fd_r(-1),fd_w(-1),
changed(false),
size_initialized(false),
size_not_accurate(false),
control_enabled(false),
t_cols(0),t_rows(0),
pos_x(0),pos_y(0),
rbuf(NULL),
... | pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x50(%rdi)
movb $0x1, 0x58(%rdi)
movq $-0x1, 0x5c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x64(%rdi)
movups %xmm0, 0x74(%rdi)
movups %xmm0, 0x84(%rdi)
movups %xmm0, 0x94(%rdi)
movups %xmm0, 0xa0(%rdi)
movl $0xa, %esi
popq %rbp
jmp 0x93c0
nop
| /roelfdutoit[P]libchars/terminal.cpp |
libchars::terminal_driver::get_terminal_width_and_height() | void terminal_driver::get_terminal_width_and_height()
{
if (!control_enabled) {
t_cols = t_rows = 0;
changed = false;
}
else if (fd_w > 0) {
if (!size_initialized) {
struct winsize ws;
ws.ws_col = 0;
if (ioct... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x67(%rdi)
je 0x12dda
movl 0x60(%rbx), %edi
testl %edi, %edi
jle 0x12dea
cmpb $0x0, 0x65(%rbx)
je 0x12dfa
cmpb $0x0, 0x66(%rbx)
jne 0x12eb5
leaq -0x10(%rbp), %rdx
movw $0x0, 0x2(%rdx)
movl $0x5413, %esi # imm = 0x5413
xorl %eax,... | /roelfdutoit[P]libchars/terminal.cpp |
libchars::terminal_driver::write(char const*, unsigned long) | int terminal_driver::write(const char *sequence, size_t seqlen)
{
const char *const seqend = sequence + seqlen;
while (sequence < seqend) {
ssize_t n = ::write(fd_w, sequence, (size_t)(seqend - sequence));
if (n > 0) {
sequence += n;
}
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
jle 0x131f8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq %rsi, %rbx
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl 0x60(%r15), %edi
movq %rbx, %rdx
subq %r14, %rdx
movq %r14, %rsi
callq 0x91c0
testq %rax, %rax
jle 0x13... | /roelfdutoit[P]libchars/terminal.cpp |
libchars::terminal_driver::read(unsigned char&, unsigned long) | int terminal_driver::read(uint8_t &c, size_t timeout_s)
{
if (rbuf_enq <= rbuf_deq) {
struct timeval T_start;
gettimeofday(&T_start, NULL);
uint64_t t_msec_start = T_start.tv_sec * 1000ULL + T_start.tv_usec/1000ULL;
uint64_t timeout_ms = timeout_s * 1000UL;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa8(%rdi), %rax
cmpq %rax, 0xa0(%rdi)
ja 0x13623
movq %rdx, %r15
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x9b50
movq 0xa8(%rbx), %rax
cmpq %rax, 0xa0(%rbx)
ja 0x13623
movq -0x40(... | /roelfdutoit[P]libchars/terminal.cpp |
libchars::validation::add_validator__(int, libchars::validator const*) | int validation::add_validator__(validator::id_t id, const validator *v)
{
if (v == NULL)
return -1;
if (id == validator::NONE)
return -1;
validators_by_id_t::const_iterator ii = i2v.find(id);
if (ii != i2v.end())
return -1; // duplicate
i... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, -0x2c(%rbp)
testq %rdx, %rdx
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
jne 0x137b5
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movq 0x40(%rdi), %rax
testq %r... | /roelfdutoit[P]libchars/validation.cpp |
libchars::validation::get_vtype_by_name(char const*) | const validator::id_t validation::get_vtype_by_name(const char *name)
{
if (name == NULL)
return validator::NONE;
vtype_by_name_t::const_iterator ni = n2i.find(name);
if (ni != n2i.end())
return ni->second;
else
return validator::NONE;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x13879
movq %rsi, %r15
movq %rdi, %r14
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0x9250
leaq (%rax,%r15), %rdx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r1... | /roelfdutoit[P]libchars/validation.cpp |
bool (anonymous namespace)::SolverDpllTriadSimd<0>::BoxRestrict<1>((anonymous namespace)::State&, int, Bitvec16x16 const&) | static bool BoxRestrict(State &state, int box_idx, const Cells16 &candidates) {
// return immediately if there are no new eliminations
Box &box = state.boxen[box_idx];
if (box.cells.SubsetOf(candidates)) return true;
auto eliminating = box.cells.and_not(candidates);
int box_i = ... | pushq %r15
pushq %r14
pushq %rbx
movslq %esi, %rcx
movb $0x1, %al
movq %rcx, %rdx
shlq $0x5, %rdx
vmovdqa 0xc0(%rdi,%rdx), %ymm7
vptest %ymm7, %ymm0
jb 0x6f5c
leaq 0x54a6(%rip), %rsi # 0xc200
vmovdqa 0x6c1e(%rip), %ymm1 # 0xd980
vmovdqa 0x6c36(%rip), %ymm2 # 0xd9a0
vmovdqa 0x6c4e(%rip), %ymm3 # 0xd9c0
... | /t-dillon[P]tdoku/src/solver_dpll_triad_simd.cc |
nng_listener_create_url | int
nng_listener_create_url(nng_listener *lp, nng_socket sid, const nng_url *url)
{
nni_sock *s;
int rv;
nni_listener *l;
nng_listener lid;
if ((rv = nni_sock_find(&s, sid.id)) != 0) {
return (rv);
}
if ((rv = nni_listener_create_url(&l, s, url)) != 0) {
nni_sock_rele(s);
return (rv);
}
l... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1912b
movl %eax, %r14d
testl %eax, %eax
jne 0x11e34
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %r15, %rdx
callq 0x1669b
testl %eax, %eax
je 0x11e1d
movl %eax, %r14d
movq -0... | /nanomsg[P]nng/src/nng.c |
nng_dialer_create | int
nng_dialer_create(nng_dialer *dp, nng_socket sid, const char *addr)
{
nni_sock *s;
nni_dialer *d;
int rv;
nng_dialer did;
if ((rv = nni_sock_find(&s, sid.id)) != 0) {
return (rv);
}
if ((rv = nni_dialer_create(&d, s, addr)) != 0) {
nni_sock_rele(s);
return (rv);
}
did.id = nni_dialer_id(d... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1912b
movl %eax, %r14d
testl %eax, %eax
jne 0x11ef0
movq -0x28(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %r15, %rdx
callq 0x151cd
testl %eax, %eax
je 0x11ed9
movl %eax, %r14d
movq -0... | /nanomsg[P]nng/src/nng.c |
dialer_set | static int
dialer_set(nng_dialer id, const char *n, const void *v, size_t sz, nni_type t)
{
nni_dialer *d;
int rv;
if ((rv = nni_dialer_find(&d, id.id)) != 0) {
return (rv);
}
rv = nni_dialer_setopt(d, n, v, sz, t);
nni_dialer_rele(d);
return (rv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %esi
leaq -0x30(%rbp), %rdi
callq 0x15295
movl %eax, %r13d
testl %eax, %eax
jne 0x1202e
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14... | /nanomsg[P]nng/src/nng.c |
dialer_get | static int
dialer_get(nng_dialer id, const char *n, void *v, size_t *szp, nni_type t)
{
nni_dialer *d;
int rv;
if ((rv = nni_dialer_find(&d, id.id)) != 0) {
return (rv);
}
rv = nni_dialer_getopt(d, n, v, szp, t);
nni_dialer_rele(d);
return (rv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %esi
leaq -0x28(%rbp), %rdi
callq 0x15295
movl %eax, %r12d
testl %eax, %eax
jne 0x12168
movq -0x28(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movl %ebx, %r8... | /nanomsg[P]nng/src/nng.c |
nng_dialer_set_tls | int
nng_dialer_set_tls(nng_dialer id, nng_tls_config *cfg)
{
int rv;
nni_dialer *d;
if ((rv = nni_dialer_find(&d, id.id)) != 0) {
return (rv);
}
rv = nni_dialer_set_tls(d, cfg);
nni_dialer_rele(d);
return (rv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %esi
leaq -0x18(%rbp), %rdi
callq 0x15295
movl %eax, %r14d
testl %eax, %eax
jne 0x12236
movq -0x18(%rbp), %rdi
movq %rbx, %rsi
callq 0x15823
movl %eax, %r14d
movq -0x18(%rbp), %rdi
callq 0x15328
movl %r14d, %eax
addq $0x10, %rs... | /nanomsg[P]nng/src/nng.c |
listener_set | static int
listener_set(
nng_listener lid, const char *name, const void *v, size_t sz, nni_type t)
{
nni_listener *l;
int rv;
if ((rv = nni_listener_find(&l, lid.id)) != 0) {
return (rv);
}
rv = nni_listener_setopt(l, name, v, sz, t);
nni_listener_rele(l);
return (rv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %esi
leaq -0x30(%rbp), %rdi
callq 0x16b4e
movl %eax, %r13d
testl %eax, %eax
jne 0x122b6
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14... | /nanomsg[P]nng/src/nng.c |
nng_dialer_get_url | int
nng_dialer_get_url(nng_dialer id, const nng_url **urlp)
{
int rv;
nni_dialer *d;
if ((rv = nni_dialer_find(&d, id.id)) != 0) {
return (rv);
}
*urlp = nni_dialer_url(d);
nni_dialer_rele(d);
return (0);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %esi
leaq -0x10(%rbp), %rdi
callq 0x15295
testl %eax, %eax
jne 0x1253d
movq -0x10(%rbp), %rdi
callq 0x1583e
movq %rax, (%rbx)
movq -0x10(%rbp), %rdi
callq 0x15328
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /nanomsg[P]nng/src/nng.c |
nng_listener_get_url | int
nng_listener_get_url(nng_listener id, const nng_url **urlp)
{
int rv;
nni_listener *l;
if ((rv = nni_listener_find(&l, id.id)) != 0) {
return (rv);
}
*urlp = nni_listener_url(l);
nni_listener_rele(l);
return (0);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %esi
leaq -0x10(%rbp), %rdi
callq 0x16b4e
testl %eax, %eax
jne 0x12573
movq -0x10(%rbp), %rdi
callq 0x16dc1
movq %rax, (%rbx)
movq -0x10(%rbp), %rdi
callq 0x16be1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /nanomsg[P]nng/src/nng.c |
nng_dialer_close | int
nng_dialer_close(nng_dialer did)
{
nni_dialer *d;
int rv;
if ((rv = nni_dialer_find(&d, did.id)) != 0) {
return (rv);
}
nni_dialer_close(d);
return (0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, %esi
leaq -0x8(%rbp), %rdi
callq 0x15295
testl %eax, %eax
jne 0x1259c
movq -0x8(%rbp), %rdi
callq 0x153aa
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
| /nanomsg[P]nng/src/nng.c |
nng_listener_close | int
nng_listener_close(nng_listener lid)
{
nni_listener *l;
int rv;
if ((rv = nni_listener_find(&l, lid.id)) != 0) {
return (rv);
}
nni_listener_close(l);
return (0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, %esi
leaq -0x8(%rbp), %rdi
callq 0x16b4e
testl %eax, %eax
jne 0x125c4
movq -0x8(%rbp), %rdi
callq 0x16c63
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
| /nanomsg[P]nng/src/nng.c |
nng_socket_get_send_poll_fd | int
nng_socket_get_send_poll_fd(nng_socket id, int *fdp)
{
int rv;
nni_sock *sock;
if ((rv = nni_sock_find(&sock, id.id)) != 0) {
return (rv);
}
rv = nni_sock_get_send_fd(sock, fdp);
nni_sock_rele(sock);
return (rv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %esi
leaq -0x18(%rbp), %rdi
callq 0x1912b
movl %eax, %r14d
testl %eax, %eax
jne 0x127cb
movq -0x18(%rbp), %rdi
movq %rbx, %rsi
callq 0x1906c
movl %eax, %r14d
movq -0x18(%rbp), %rdi
callq 0x191b2
movl %r14d, %eax
addq $0x10, %rs... | /nanomsg[P]nng/src/nng.c |
nng_socket_peer_name | int
nng_socket_peer_name(nng_socket id, const char **name)
{
int rv;
nni_sock *sock;
if ((rv = nni_sock_find(&sock, id.id)) != 0) {
return (rv);
}
*name = nni_sock_peer_name(sock);
nni_sock_rele(sock);
return (0);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %esi
leaq -0x10(%rbp), %rdi
callq 0x1912b
testl %eax, %eax
jne 0x128a8
movq -0x10(%rbp), %rdi
callq 0x19c69
movq %rax, (%rbx)
movq -0x10(%rbp), %rdi
callq 0x191b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /nanomsg[P]nng/src/nng.c |
nng_device | int
nng_device(nng_socket s1, nng_socket s2)
{
nni_aio aio;
int rv;
nni_aio_init(&aio, NULL, NULL);
nng_device_aio(&aio, s1, s2);
nni_aio_wait(&aio);
rv = nni_aio_result(&aio);
nni_aio_fini(&aio);
return (rv);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movl %esi, %ebx
movl %edi, %r14d
leaq -0x1e0(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13808
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0x1292e
movq %r15, %rdi
callq 0x13aa8
movq ... | /nanomsg[P]nng/src/nng.c |
device_cb | static void
device_cb(void *arg)
{
device_path *p = arg;
device_data *d = p->d;
int rv;
if ((rv = nni_aio_result(&p->aio)) != 0) {
nni_mtx_lock(&device_mtx);
if (p->state == NNI_DEVICE_STATE_SEND) {
nni_msg_free(nni_aio_get_msg(&p->aio));
nni_aio_set_msg(&p->aio, NULL);
}
p->state = NNI_DEVI... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, %rdi
callq 0x13bdf
testl %eax, %eax
je 0x14c10
movl %eax, %r15d
leaq 0x47e14(%rip), %rdi # 0x5c970
callq 0x1c4b4
cmpl $0x2, (%r14)
jne 0x14b81
movq %r12,... | /nanomsg[P]nng/src/core/device.c |
nni_dialer_setopt | int
nni_dialer_setopt(
nni_dialer *d, const char *name, const void *val, size_t sz, nni_type t)
{
nni_option *o;
if (strcmp(name, NNG_OPT_RECONNMAXT) == 0) {
int rv;
nni_mtx_lock(&d->d_mtx);
rv = nni_copyin_ms(&d->d_maxrtime, val, sz, t);
nni_mtx_unlock(&d->d_mtx);
return (rv);
}
if (strcmp(name, NNG... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r15d
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x2c00c(%rip), %rsi # 0x4156f
movq %r13, %rdi
callq 0x95d0
testl %eax, %eax
je 0x155f9
leaq 0x2c008(%rip), %rsi # 0x41582
movq ... | /nanomsg[P]nng/src/core/dialer.c |
nni_dialer_getopt | int
nni_dialer_getopt(
nni_dialer *d, const char *name, void *valp, size_t *szp, nni_type t)
{
nni_option *o;
if (strcmp(name, NNG_OPT_RECONNMAXT) == 0) {
int rv;
nni_mtx_lock(&d->d_mtx);
rv = nni_copyout_ms(d->d_maxrtime, valp, szp, t);
nni_mtx_unlock(&d->d_mtx);
return (rv);
}
if (strcmp(name, NNG_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
leaq 0x2be99(%rip), %rsi # 0x4156f
movq %r13, %rdi
callq 0x95d0
testl %eax, %eax
je 0x15780
leaq 0x2be95(%rip), %rsi # 0x41582
movq %r13, %... | /nanomsg[P]nng/src/core/dialer.c |
nni_id_map_sys_fini | void
nni_id_map_sys_fini(void)
{
nni_mtx_lock(&id_reg_mtx);
for (int i = 0; i < id_reg_num; i++) {
if (id_reg_map[i] != NULL) {
nni_id_map_fini(id_reg_map[i]);
}
}
nni_free(id_reg_map, sizeof(nni_id_map *) * id_reg_len);
id_reg_map = NULL;
id_reg_len = 0;
id_reg_num = 0;
nni_mtx_unlock(&id_reg_mtx);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x46ec1(%rip), %rdi # 0x5c9c0
callq 0x1c4b4
cmpl $0x0, 0x46edd(%rip) # 0x5c9e8
jle 0x15b60
xorl %ebx, %ebx
movq 0x46eda(%rip), %rax # 0x5c9f0
movq (%rax,%rbx,8), %r14
testq %r14, %r14
je 0x15b51
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x15b51
movl 0x4(... | /nanomsg[P]nng/src/core/idhash.c |
nni_id_remove | int
nni_id_remove(nni_id_map *m, uint64_t id)
{
size_t index;
size_t probe;
if ((index = id_find(m, id)) == (size_t) -1) {
return (NNG_ENOENT);
}
// Now we have found the index where the object exists. We are going
// to restart the search, until the index matches, to decrement the
// skips counter.
probe ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x15a9d
cmpq $-0x1, %rax
je 0x15c45
movq %rax, %r15
movl 0x4(%rbx), %eax
decl %eax
andl %eax, %r14d
xorl %r13d, %r13d
decl 0xc(%rbx)
leaq (%r14,%r14,2), %r12
shlq $0x3, %r12
addq 0x30(%rbx)... | /nanomsg[P]nng/src/core/idhash.c |
nni_id_alloc | int
nni_id_alloc(nni_id_map *m, uint64_t *idp, void *val)
{
uint64_t id;
int rv;
NNI_ASSERT(val != NULL);
// range is inclusive, so > to get +1 effect.
if (m->id_count > (m->id_max_val - m->id_min_val)) {
// Really more like ENOSPC.. the table is filled to max.
return (NNG_ENOMEM);
}
if (m->id_dyn_val... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
jne 0x15fc2
leaq 0x2b378(%rip), %rdi # 0x41320
leaq 0x2b724(%rip), %rsi # 0x416d3
leaq 0x2b788(%rip), %rcx # 0x4173e
movl $0x143, %edx # im... | /nanomsg[P]nng/src/core/idhash.c |
nni_list_insert_after | void
nni_list_insert_after(nni_list *list, void *item, void *after)
{
nni_list_node *node = NODE(list, item);
nni_list_node *where = NODE(list, after);
if ((node->ln_next != NULL) || (node->ln_prev != NULL)) {
nni_panic("inserting node already on a list or not inited");
}
node->ln_prev = where;
node-... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x10(%rdi), %r15
leaq (%rsi,%r15), %r14
cmpq $0x0, (%rsi,%r15)
jne 0x164de
cmpq $0x0, 0x8(%r14)
je 0x164ec
leaq 0x2b320(%rip), %rdi # 0x41805
xorl %eax, %eax
callq 0x181a9
leaq (%rbx,%r15), %rax
movq %rax, 0x8(%r14)
movq (%r... | /nanomsg[P]nng/src/core/list.c |
nni_listener_bump_error | void
nni_listener_bump_error(nni_listener *l, int err)
{
#ifdef NNG_ENABLE_STATS
switch (err) {
case NNG_ECONNABORTED:
case NNG_ECONNRESET:
nni_stat_inc(&l->st_disconnect, 1);
break;
case NNG_ECANCELED:
nni_stat_inc(&l->st_canceled, 1);
break;
case NNG_ETIMEDOUT:
nni_stat_inc(&l->st_timeout, 1);
break;... | pushq %rbp
movq %rsp, %rbp
leal -0xd(%rsi), %eax
cmpl $0xe, %eax
ja 0x1665b
leaq 0x2b1e9(%rip), %rcx # 0x41834
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x658, %eax # imm = 0x658
jmp 0x1668d
cmpl $0x2, %esi
je 0x16688
cmpl $0x5, %esi
jne 0x16673
movl $0x718, %eax # imm = 0x71... | /nanomsg[P]nng/src/core/listener.c |
nni_listener_init | static int
nni_listener_init(nni_listener *l, nni_sock *s, nni_sp_tran *tran)
{
int rv;
void *lp;
l->l_closed = false;
l->l_data = NULL;
l->l_ref = 1;
l->l_sock = s;
l->l_tran = tran;
nni_atomic_flag_reset(&l->l_started);
// Make a copy of the endpoint operations. This allows us to
// modify the... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movb $0x0, 0x9c(%rdi)
movq $0x0, 0x70(%rdi)
movl $0x1, 0x98(%rdi)
movq %rsi, -0x30(%rbp)
movq %rsi, 0x90(%rdi)
movq %rdx, 0x68(%rdi)
addq $0x9e, %rdi
callq 0x1d5ec
movq 0x20(%r14), %rsi
movl $0xd... | /nanomsg[P]nng/src/core/listener.c |
nni_listener_create | int
nni_listener_create(nni_listener **lp, nni_sock *s, const char *url_str)
{
nni_sp_tran *tran;
nni_listener *l;
int rv;
size_t sz;
if (((tran = nni_sp_tran_find(url_str)) == NULL) ||
(tran->tran_listener == NULL)) {
return (NNG_ENOTSUP);
}
sz = NNI_ALIGN_UP(sizeof(*l)) + tran->tran_l... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x1fc10
movl $0x9, %r14d
testq %rax, %rax
je 0x16b3c
movq %rax, %r12
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x16b3c
movq %r15, -0x38(%rbp)
movq %rbx... | /nanomsg[P]nng/src/core/listener.c |
nni_listener_find | int
nni_listener_find(nni_listener **lp, uint32_t id)
{
nni_listener *l;
nni_mtx_lock(&listeners_lk);
if ((l = nni_id_get(&listeners, id)) != NULL) {
l->l_ref++;
*lp = l;
}
nni_mtx_unlock(&listeners_lk);
return (l == NULL ? NNG_ENOENT : 0);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x45eb6(%rip), %rdi # 0x5ca18
callq 0x1c4b4
movl %r14d, %esi
leaq 0x4494f(%rip), %rdi # 0x5b4c0
callq 0x15a71
testq %rax, %rax
je 0x16b88
incl 0x98(%rax)
movq %rax, (%rbx)
xorl %ebx, %ebx
jmp 0x16b8d
movl $0xc, %ebx
leaq 0x45... | /nanomsg[P]nng/src/core/listener.c |
nni_listener_rele | void
nni_listener_rele(nni_listener *l)
{
bool reap;
nni_mtx_lock(&listeners_lk);
NNI_ASSERT(l->l_ref > 0);
l->l_ref--;
reap = ((l->l_ref == 0) && (l->l_closed));
nni_mtx_unlock(&listeners_lk);
if (reap) {
nni_listener_reap(l);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x45e26(%rip), %rdi # 0x5ca18
callq 0x1c4b4
cmpl $0x0, 0x98(%rbx)
jg 0x16c21
leaq 0x2a719(%rip), %rdi # 0x41320
leaq 0x2ac62(%rip), %rsi # 0x41870
leaq 0x2acaf(%rip), %rcx # 0x418c4
movl $0x165, %edx # imm = 0x165
xorl %eax... | /nanomsg[P]nng/src/core/listener.c |
nni_listener_setopt | int
nni_listener_setopt(
nni_listener *l, const char *name, const void *val, size_t sz, nni_type t)
{
nni_option *o;
if (l->l_ops.l_setopt != NULL) {
int rv = l->l_ops.l_setopt(l->l_data, name, val, sz, t);
if (rv != NNG_ENOTSUP) {
return (rv);
}
}
for (o = l->l_ops.l_options; o && o->o_name; o++) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x16e59
movq 0x70(%r12), %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rcx, %rbx
movl %r14d, %r8d
callq *%rax
movq %r... | /nanomsg[P]nng/src/core/listener.c |
nni_listener_add_stat | void
nni_listener_add_stat(nni_listener *l, nni_stat_item *item)
{
#ifdef NNG_ENABLE_STATS
nni_stat_add(&l->st_root, item);
#else
NNI_ARG_UNUSED(l);
NNI_ARG_UNUSED(item);
#endif
} | pushq %rbp
movq %rsp, %rbp
addq $0x518, %rdi # imm = 0x518
popq %rbp
jmp 0x1b214
| /nanomsg[P]nng/src/core/listener.c |
nni_msg_unique | nni_msg *
nni_msg_unique(nni_msg *m)
{
nni_msg *m2;
// If we already have an exclusive copy, just keep using it.
if (nni_atomic_get(&m->m_refcnt) == 1) {
return (m);
}
// Otherwise we need to make a copy
if (nni_msg_dup(&m2, m) != 0) {
m2 = NULL;
}
nni_msg_free(m);
return (m2);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x6c, %rdi
callq 0x1d660
cmpl $0x1, %eax
je 0x17621
leaq -0x10(%rbp), %rdi
movq %rbx, %rsi
callq 0x1762b
testl %eax, %eax
je 0x17615
movq $0x0, -0x10(%rbp)
movq %rbx, %rdi
callq 0x1770d
movq -0x10(%rbp), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rb... | /nanomsg[P]nng/src/core/message.c |
nni_msg_pull_up | nni_msg *
nni_msg_pull_up(nni_msg *m)
{
// This implementation is optimized to ensure that this function
// will not copy the message more than once, and it will not
// allocate unless there is no other option.
if (((nni_chunk_room(&m->m_body) < nni_msg_header_len(m))) ||
(nni_atomic_get(&m->m_refcnt) != 1)) {... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
subq 0x50(%rdi), %rax
cmpq 0x40(%rdi), %rax
jb 0x177c2
leaq 0x6c(%rbx), %rdi
callq 0x1d660
cmpl $0x1, %eax
jne 0x177c2
movq 0x40(%rbx), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x1796b
movq $0... | /nanomsg[P]nng/src/core/message.c |
nni_msg_header_insert | int
nni_msg_header_insert(nni_msg *m, const void *data, size_t len)
{
if ((len + m->m_header_len) > sizeof(m->m_header_buf)) {
return (NNG_EINVAL);
}
memmove(((uint8_t *) m->m_header_buf) + len, m->m_header_buf,
m->m_header_len);
memcpy(m->m_header_buf, data, len);
m->m_header_len += len;
return (0);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x40(%rdi), %rdx
leaq (%rdx,%rbx), %rcx
movl $0x3, %eax
cmpq $0x40, %rcx
ja 0x17d3e
movq %rsi, %r15
movq %rdi, %r14
addq %rbx, %rdi
movq %r14, %rsi
callq 0x9500
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x97c0
addq %... | /nanomsg[P]nng/src/core/message.c |
nni_copyin_str | int
nni_copyin_str(char *s, const void *v, size_t maxsz, nni_type t)
{
size_t z;
if (t != NNI_TYPE_STRING) {
return (NNG_EBADTYPE);
}
z = nni_strnlen(v, maxsz);
if (z == maxsz && ((char *) v)[maxsz - 1] != 0) {
return (NNG_EINVAL); // too long
}
memcpy(s, v, z);
s[z] = 0;
return (0);
} | movl $0x1e, %eax
cmpl $0x5, %ecx
jne 0x17f37
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1bce9
movq %rax, %r12
cmpq %r15, %rax
jne 0x17f1a
movl $0x3, %eax
cmpb $0x0, -0x1(%r14,%r15)
jne 0x17f2f
movq %rbx, ... | /nanomsg[P]nng/src/core/options.c |
nni_thr_fini | void
nni_thr_fini(nni_thr *thr)
{
if (!thr->init) {
return;
}
nni_plat_mtx_lock(&thr->mtx);
thr->stop = 1;
nni_plat_cv_wake(&thr->cv);
while (!thr->done) {
nni_plat_cv_wait(&thr->cv);
}
nni_plat_mtx_unlock(&thr->mtx);
if (thr->fn != NULL) {
nni_plat_thr_fini(&thr->thr);
}
nni_plat_cv_fini(&thr->cv);
... | cmpl $0x0, 0x94(%rdi)
je 0x1c73a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x1e44b
movl $0x1, 0x8c(%rbx)
leaq 0x40(%rbx), %r15
movq %r15, %rdi
callq 0x1e513
cmpl $0x0, 0x90(%rbx)
jne 0x1c6ff
movq %r15, %rdi
callq 0x1e563
jmp 0x1c6e... | /nanomsg[P]nng/src/core/thread.c |
nni_url_decode | size_t
nni_url_decode(uint8_t *out, const char *in, size_t max_len)
{
size_t len;
uint8_t c;
len = 0;
while ((c = (uint8_t) *in) != '\0') {
if (len >= max_len) {
return ((size_t) -1);
}
if (c == '%') {
in++;
if ((!isxdigit(in[0])) || (!isxdigit(in[1]))) {
return ((size_t) -1);
}
out[len] ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb (%rsi), %al
testb %al, %al
je 0x1c840
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
movq $-0x1, %r12
cmpq %r13, %rbx
je 0x1c843
cmpb $0x25, %al
jne 0x1c7d1
callq 0x93c0
movq (%rax), %rax
movsbq 0x1(%r14... | /nanomsg[P]nng/src/core/url.c |
udp_pipe_fini | static void
udp_pipe_fini(void *arg)
{
udp_pipe *p = arg;
nng_msg *m;
// call with ep->mtx lock held
while (!nni_lmq_empty(&p->rx_mq)) {
nni_lmq_get(&p->rx_mq, &m);
nni_msg_free(m);
}
nni_lmq_fini(&p->rx_mq);
NNI_ASSERT(nni_list_empty(&p->rx_aios));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe0(%rdi), %r14
movq %r14, %rdi
callq 0x32a81
testb %al, %al
jne 0x2cf7a
leaq -0x20(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x32ac8
movq -0x20(%rbp), %rdi
callq 0x1770d
movq %r14, %rdi
callq 0x32a81
testb %al, %al
je ... | /nanomsg[P]nng/src/sp/transport/udp/udp.c |
udp_pipe_stop | static void
udp_pipe_stop(void *arg)
{
udp_pipe *p = arg;
udp_ep *ep = p->ep;
udp_pipe_close(arg);
nni_mtx_lock(&ep->mtx);
if (p->self_id != 0) {
nni_id_remove(&p->ep->pipes, p->self_id);
p->self_id = 0;
}
nni_list_node_remove(&p->node);
nni_mtx_unlock(&ep->mtx);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
callq 0x2d1f3
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x1c4b4
movl 0x9c(%r14), %esi
testq %rsi, %rsi
je 0x2d003
movl $0x820, %edi # imm = 0x820
addq (%r14), %rdi
callq 0x15ba0
movl $0x0, 0x9c(%r14)
addq $0xd0, %r14
movq %r14, %r... | /nanomsg[P]nng/src/sp/transport/udp/udp.c |
ws_close_cb | static void
ws_close_cb(void *arg)
{
nni_ws *ws = arg;
ws_frame *frame;
nni_aio_close(&ws->txaio);
nni_aio_close(&ws->rxaio);
nni_aio_close(&ws->httpaio);
// Either we sent a close frame, or we didn't. Either way,
// we are done, and its time to abort everything else.
nni_mtx_lock(&ws->mtx);
nni_http_con... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xf8, %rdi
callq 0x13ac7
leaq 0x2c0(%rbx), %rdi
callq 0x13ac7
leaq 0x650(%rbx), %rdi
callq 0x13ac7
leaq 0x60(%rbx), %r14
movq %r14, %rdi
callq 0x1c4b4
movq 0x9e8(%rbx), %rdi
callq 0x36f32
addq $0xb8, %rbx
movq %rbx, %rdi
callq ... | /nanomsg[P]nng/src/supplemental/websocket/websocket.c |
ws_stop | static void
ws_stop(void *arg)
{
nni_ws *ws = arg;
ws_close_error(ws, WS_CLOSE_NORMAL_CLOSE);
// Give a chance for the close frame to drain.
nni_aio_wait(&ws->closeaio);
nni_aio_stop(&ws->rxaio);
nni_aio_stop(&ws->txaio);
nni_aio_stop(&ws->closeaio);
nni_aio_stop(&ws->httpaio);
if (nni_list_node_active(&ws-... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
movq %r14, %rdi
callq 0x1c4b4
movq %rbx, %rdi
movl $0x3e8, %esi # imm = 0x3E8
callq 0x309f0
movq %r14, %rdi
callq 0x1c4be
leaq 0x488(%rbx), %r14
movq %r14, %rdi
callq 0x13aa8
leaq 0x2c0(%rbx), %rdi
ca... | /nanomsg[P]nng/src/supplemental/websocket/websocket.c |
ws_str_send | static void
ws_str_send(void *arg, nni_aio *aio)
{
nni_ws *ws = arg;
int rv;
ws_frame *frame;
nni_aio_reset(aio);
if (!ws->isstream) {
nni_msg *msg;
unsigned niov;
nni_iov iov[2];
if ((msg = nni_aio_get_msg(aio)) == NULL) {
nni_aio_finish_error(aio, NNG_EINVAL);
return;
}
niov = 0;
i... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x13bff
cmpb $0x0, 0x55(%r14)
jne 0x3040b
movq %rbx, %rdi
callq 0x13b76
movq %rax, %r15
testq %rax, %rax
je 0x303c1
movq %r15, %rdi
callq 0x12c93
testq %rax, %rax
je 0... | /nanomsg[P]nng/src/supplemental/websocket/websocket.c |
nng_http_read | void
nng_http_read(nng_http *conn, nng_aio *aio)
{
#ifdef NNG_SUPP_HTTP
nni_http_read(conn, aio);
#else
NNI_ARG_UNUSED(conn);
nni_aio_finish_error(aio, NNG_ENOTSUP);
#endif
} | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x37502
| /nanomsg[P]nng/src/supplemental/http/http_public.c |
nng_http_read_all | void
nng_http_read_all(nng_http *conn, nng_aio *aio)
{
#ifdef NNG_SUPP_HTTP
nni_http_read_full(conn, aio);
#else
NNI_ARG_UNUSED(conn);
nni_aio_finish_error(aio, NNG_ENOTSUP);
#endif
} | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x37462
| /nanomsg[P]nng/src/supplemental/http/http_public.c |
nng_http_write | void
nng_http_write(nng_http *conn, nng_aio *aio)
{
#ifdef NNG_SUPP_HTTP
nni_http_write(conn, aio);
#else
NNI_ARG_UNUSED(conn);
nni_aio_finish_error(aio, NNG_ENOTSUP);
#endif
} | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x3781f
| /nanomsg[P]nng/src/supplemental/http/http_public.c |
plat_walker | static int
plat_walker(const char *name, void *arg)
{
struct walkdata *w = arg;
int rv;
rv = w->fn(name, w->arg);
switch (rv) {
case NNI_FILE_WALK_CONTINUE:
return (NNI_PLAT_FILE_WALK_CONTINUE);
case NNI_FILE_WALK_STOP:
return (NNI_PLAT_FILE_WALK_STOP);
case NNI_FILE_WALK_PRUNE_CHILD:
return ... | pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
movq 0x8(%rsi), %rsi
callq *(%rax)
cmpl $0x4, %eax
movl $0x1, %ecx
cmovael %ecx, %eax
popq %rbp
retq
| /nanomsg[P]nng/src/core/file.c |
nni_file_lock | int
nni_file_lock(const char *path, nni_file_lockh **hp)
{
nni_file_lockh *h;
int rv;
if ((h = NNI_ALLOC_STRUCT(h)) == NULL) {
return (NNG_ENOMEM);
}
rv = nni_plat_file_lock(path, &h->lk);
if (rv != 0) {
NNI_FREE_STRUCT(h);
return (rv);
}
*hp = h;
return (0);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4, %edi
callq 0x1d5bb
testq %rax, %rax
je 0x3c626
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x3cbc6
testl %eax, %eax
je 0x3c62e
movl %eax, %r14d
movl $0x4, %esi
movq %r15, %rdi
callq 0x1d5d6
jmp 0x... | /nanomsg[P]nng/src/core/file.c |
nni_plat_file_put | int
nni_plat_file_put(const char *name, const void *data, size_t len)
{
FILE *f;
int rv = 0;
// It is possible that the name contains a directory path
// that does not exist. In this case we try to create the
// entire tree.
if (strchr(name, '/') != NULL) {
if ((rv = nni_plat_make_parent_dirs(name)) != 0) {... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x9510
testq %rax, %rax
je 0x3c72a
movq %r13, -0x30(%rbp)
movq %rbx, %rdi
callq 0x1bc54
testq %rax, %rax
je 0x3c709
movq %rax, %r13
movq %rax, %rdi
movl $0x... | /nanomsg[P]nng/src/platform/posix/posix_file.c |
nni_plat_file_get | int
nni_plat_file_get(const char *name, void **datap, size_t *lenp)
{
FILE * f;
struct stat st;
int rv = 0;
size_t len;
void * data;
if ((f = fopen(name, "rb")) == NULL) {
return (nni_plat_errno(errno));
}
if (stat(name, &st) != 0) {
rv = nni_plat_errno(errno);
(void) fclose(f);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x865c(%rip), %rsi # 0x44e27
callq 0x9270
testq %rax, %rax
je 0x3c80a
movq %rax, %rbx
leaq -0xb8(%rbp), %rsi
movq %r12, %rdi
callq 0x9780
testl %eax, %eax
je 0x3c8... | /nanomsg[P]nng/src/platform/posix/posix_file.c |
nni_plat_file_delete | int
nni_plat_file_delete(const char *name)
{
if (rmdir(name) == 0) {
return (0);
}
if ((errno == ENOTDIR) && (unlink(name) == 0)) {
return (0);
}
if (errno == ENOENT) {
return (0);
}
return (nni_plat_errno(errno));
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x9290
testl %eax, %eax
je 0x3c8dc
callq 0x9590
movq %rax, %r14
cmpl $0x14, (%rax)
jne 0x3c8d4
movq %rbx, %rdi
callq 0x9280
testl %eax, %eax
je 0x3c8dc
movl (%r14), %edi
cmpl $0x2, %edi
jne 0x3c8e3
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
... | /nanomsg[P]nng/src/platform/posix/posix_file.c |
nni_plat_file_type | int
nni_plat_file_type(const char *name, int *typep)
{
struct stat sbuf;
if (stat(name, &sbuf) != 0) {
return (nni_plat_errno(errno));
}
switch (sbuf.st_mode & S_IFMT) {
case S_IFREG:
*typep = NNI_PLAT_FILE_TYPE_FILE;
break;
case S_IFDIR:
*typep = NNI_PLAT_FILE_TYPE_DIR;
break;
default:
*typep = NNI... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
leaq -0x98(%rbp), %rsi
callq 0x9780
testl %eax, %eax
je 0x3c920
callq 0x9590
movl (%rax), %edi
addq $0x98, %rsp
popq %rbx
popq %rbp
jmp 0x1d8dd
movl $0xf000, %eax # imm = 0xF000
andl -0x80(%rbp), %eax
cmpl $0x4000, %eax # imm = 0... | /nanomsg[P]nng/src/platform/posix/posix_file.c |
sfd_get_peer_pid | static int
sfd_get_peer_pid(void *arg, void *buf, size_t *szp, nni_type t)
{
nni_sfd_conn *c = arg;
int rv;
int ignore;
int id = 0;
rv = nni_posix_peerid(c->fd, &ignore, &ignore, &id, &ignore);
if (rv != 0) {
return (rv);
}
if (id == -1) {
// NB: -1 is not a legal process id
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
leaq -0x1c(%rbp), %rcx
movl $0x0, (%rcx)
movl 0x70(%rdi), %edi
leaq -0x20(%rbp), %rdx
movq %rdx, %rsi
movq %rdx, %r8
callq 0x3d67c
testl %eax, %eax
jne 0x3decd
movl -0x1c(%rbp), %edi
cmpl $-0x1, %edi
j... | /nanomsg[P]nng/src/platform/posix/posix_sockfd.c |
Catch::handleExceptionMatchExpr(Catch::AssertionHandler&, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Catch::StringRef const&) | void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString ) {
std::string exceptionMessage = Catch::translateActiveException();
MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
handler.han... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3458c
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq (%rax), %rcx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
leaq 0x28(%r15), %rdi
movq 0x28(%r15), %rax
movq %r12, %... | /olivermichel[P]libom2/test/include/catch.h |
Catch::TestGroupStats::TestGroupStats(Catch::GroupInfo const&, Catch::Totals const&, bool) | TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
Totals const& _totals,
bool _aborting )
: groupInfo( _groupInfo ),
totals( _totals ),
aborting( _aborting )
{} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8caec(%rip), %rax # 0xa9a20
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r12), %rax
movq %rax, 0x8(%r12)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x417c2
movups 0x20(%r15... | /olivermichel[P]libom2/test/include/catch.h |
Catch::RunContext::populateReaction(Catch::AssertionReaction&) | void RunContext::populateReaction( AssertionReaction& reaction ) {
reaction.shouldDebugBreak = m_config->shouldDebugBreak();
reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xe0(%rdi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, (%rbx)
movq 0xe0(%r14), %rdi
movq 0x100(%r14), %r15
movq (%rdi), %rax
callq *0x48(%rax)
cltq
movb 0x190(%r14), %cl
andb $0x1, %cl
cmpq %rax, %r15
movzbl %cl, %eax
movl $0x1, %ecx
cmovbl %... | /olivermichel[P]libom2/test/include/catch.h |
Catch::Section::~Section() | Section::~Section() {
if( m_sectionIncluded ) {
SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
if( uncaught_exceptions() )
getResultCapture().sectionEndedEarly( endInfo );
else
getResultCapture().sectionEnded( endI... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x86971(%rip), %rax # 0xa9f08
movq %rax, (%rdi)
cmpb $0x1, 0x90(%rdi)
jne 0x2367e
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x417c2
leaq 0x20(%rsp), %rdi
leaq 0x... | /olivermichel[P]libom2/test/include/catch.h |
Catch::Session::showHelp() const | void Session::showHelp() const {
Catch::cout()
<< "\nCatch v" << libraryVersion() << "\n"
<< m_cli << std::endl
<< "For more detailed usage please see the project docs\n" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8a050(%rip), %rbx # 0xadf90
leaq 0x58663(%rip), %rsi # 0x7c5aa
movl $0x8, %edx
movq %rbx, %rdi
callq 0x12670
callq 0x240e2
leaq 0x8aef8(%rip), %rsi # 0xaee58
movq %rbx, %rdi
callq 0x23ff7
leaq 0x58be5(%rip), %rsi # 0x7cb54
movl $0x1, %edx
movq %rbx... | /olivermichel[P]libom2/test/include/catch.h |
Catch::(anonymous namespace)::TestGroup::~TestGroup() | explicit TestGroup(std::shared_ptr<Config> const& config)
: m_config{config}
, m_context{config, makeReporter(config)}
{
auto const& allTestCases = getAllTestCasesSorted(*m_config);
m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_conf... | pushq %rbx
movq %rdi, %rbx
addq $0x230, %rdi # imm = 0x230
callq 0x37aaa
leaq 0x200(%rbx), %rdi
callq 0x40a9c
leaq 0x10(%rbx), %rdi
callq 0x2116a
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x252f8
popq %rbx
jmp 0x3adc4
popq %rbx
retq
| /olivermichel[P]libom2/test/include/catch.h |
Catch::TagAlias::TagAlias(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo) | TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x417c2
movq %r14, 0x20(%r15)
movq %rbx, 0x28(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
| /olivermichel[P]libom2/test/include/catch.h |
Catch::TestCase::withName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | TestCase TestCase::withName( std::string const& _newName ) const {
TestCase other( *this );
other.name = _newName;
return other;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x36738
movq 0xa8(%r15), %rax
movq %rax, 0xa8(%rbx)
movq 0xb0(%r15), %rax
movq %rax, 0xb0(%rbx)
testq %rax, %rax
je 0x26881
movq 0x87715(%rip), %rcx # 0xadf88
cmpb $0x0, (%rcx)
je 0x2687d
incl 0x8(%rax)
jmp 0x26881
lock
incl 0x8(... | /olivermichel[P]libom2/test/include/catch.h |
Catch::TestSpec::matches(Catch::TestCaseInfo const&) const | bool TestSpec::matches( TestCaseInfo const& testCase ) const {
return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %rbp
movq %rbp, %r12
subq %rbx, %r12
movq %r12, %r13
sarq $0x3, %r13
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
sarq $0x2, %r13
testq %r13, %r13
jle 0x26ca1
... | /olivermichel[P]libom2/test/include/catch.h |
Catch::TestCaseTracking::SectionTracker::tryOpen() | void SectionTracker::tryOpen() {
if( !isComplete() )
open();
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x279e3
movl $0x1, 0x60(%rbx)
movq 0x38(%rbx), %rax
movq %rbx, 0x10(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x279e3
movq (%rdi), %rax
popq %rbx
jmpq *0x68(%rax)
popq %rbx
retq
nop
| /olivermichel[P]libom2/test/include/catch.h |
Catch::TestSpecParser::addTagPattern() | void TestSpecParser::addTagPattern() {
auto token = preprocessPattern();
if (!token.empty()) {
// If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
// we have to create a separate hide tag and shorten the real one
if (token.size() > 1 && token[0] == '.... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28a14
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x28998
cmpq $0x1, %rax
je 0x288f2
movq 0x38(%rsp), %rax
cmpb $0x2e, (%rax)
jne 0x288f2
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
xorl %esi, %esi
callq 0x126b0
... | /olivermichel[P]libom2/test/include/catch.h |
Catch::ConsoleReporter::printTestFilters() | void ConsoleReporter::printTestFilters() {
if (m_config->testSpec().hasFilters()) {
Colour guard(Colour::BrightYellow);
stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x2dbb8
movb $0x0, 0x6(%rsp)
movl $0x16, %edi
callq 0x1b978
movq 0x18(%r14), %rbx
leaq 0x4f0da(%rip), %rsi # 0x7cc2d
movl $0x9, %edx
movq %rbx, %rdi
callq 0x12670... | /olivermichel[P]libom2/test/include/catch.h |
Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) | void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
std::size_t i = _string.find(": ");
if (i != std::string::npos)
i += 2;
else
i = 0;
stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4e4f0(%rip), %rsi # 0x7c6db
xorl %r12d, %r12d
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x12a00
leaq 0x2(%rax), %r13
cmpq $-0x1, %rax
cmoveq %r12, %r13
movq 0x18(%r15), %r15
lea... | /olivermichel[P]libom2/test/include/catch.h |
Catch::JunitReporter::testGroupStarting(Catch::GroupInfo const&) | void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
suiteTimer.start();
stdOutForSuite.clear();
stdErrForSuite.clear();
unexpectedExceptions = 0;
CumulativeReporterBase::testGroupStarting( groupInfo );
} | pushq %rbx
movq %rdi, %rbx
callq 0x12080
movq %rax, 0x120(%rbx)
xorl %eax, %eax
movq %rax, 0x130(%rbx)
movq 0x128(%rbx), %rcx
movb %al, (%rcx)
movq %rax, 0x150(%rbx)
movq 0x148(%rbx), %rcx
movb %al, (%rcx)
movl $0x0, 0x168(%rbx)
popq %rbx
retq
| /olivermichel[P]libom2/test/include/catch.h |
Catch::XmlReporter::XmlReporter(Catch::ReporterConfig const&) | XmlReporter::XmlReporter( ReporterConfig const& _config )
: StreamingReporterBase( _config ),
m_xml(_config.stream())
{
m_reporterPrefs.shouldRedirectStdOut = true;
m_reporterPrefs.shouldReportAllAssertions = true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x391ce
leaq 0x79f94(%rip), %rax # 0xaa4e0
movq %rax, (%rbx)
movq $0x0, 0x168(%rbx)
leaq 0x170(%rbx), %rdi
movq (%r14), %rsi
callq 0x2a1e2
movl $0x0, 0x1b8(%rbx)
movw $0x101, 0x160(%rbx) # imm = 0x101
addq $0x8, %rsp
popq %rbx
popq %r14
retq... | /olivermichel[P]libom2/test/include/catch.h |
Catch::clara::detail::BoundLambda<Catch::makeCommandLineParser(Catch::ConfigData&)::$_5>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto setValue( std::string const &arg ) -> ParserResult override {
return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x28(%rsp), %rdi
movq %rdx, %rsi
callq 0x122d0
xorl %ebp, %ebp
leaq 0xa8(%rsp), %r12
movq %rbp, -0x18(%r12)
leaq 0x... | /olivermichel[P]libom2/test/include/catch.h |
Catch::clara::TextFlow::Column::Column(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit Column(std::string const& text) { m_strings.push_back(text); } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq $0x4f, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $-0x1, 0x28(%rdi)
callq 0x3748e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x374cc
movq %r14, %rdi
callq 0x... | /olivermichel[P]libom2/test/include/catch.h |
Catch::Matchers::Exception::ExceptionMessageMatcher::ExceptionMessageMatcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ExceptionMessageMatcher(std::string const& message):
m_message(message)
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x73a05(%rip), %rax # 0xaa5d0
movq %rax, (%rdi)
leaq 0x73a2b(%rip), %rax # 0xaa600
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq ... | /olivermichel[P]libom2/test/include/catch.h |
Catch::clara::detail::BasicResult<Catch::clara::detail::ParseState>::~BasicResult() | explicit BasicResult( BasicResult<U> const &other )
: ResultValueBase<T>( other.type() ),
m_errorMessage( other.errorMessage() )
{
assert( type() != ResultBase::Ok );
} | pushq %rbx
movq %rdi, %rbx
leaq 0x74daf(%rip), %rax # 0xac0b8
movq %rax, (%rdi)
movq 0x40(%rdi), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x3731e
callq 0x12540
leaq 0x74deb(%rip), %rax # 0xac110
movq %rax, (%rbx)
cmpl $0x0, 0x8(%rbx)
je 0x37330
popq %rbx
retq
addq $0x28, %rbx
movq %rbx, %rdi
popq %rbx
jmp ... | /olivermichel[P]libom2/test/include/catch.h |
Catch::ReporterRegistrar<Catch::CompactReporter>::ReporterRegistrar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit ReporterRegistrar( std::string const& name ) {
getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x3458c
movq %rax, %r14
leaq 0x8(%rax), %r15
movl $0x18, %edi
callq 0x12590
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x74f1b(%rip), %rcx # 0xad0c8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x74f5d(%rip), ... | /olivermichel[P]libom2/test/include/catch.h |
Catch::XmlWriter& Catch::XmlWriter::writeAttribute<char [4]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [4]) | XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
ReusableStringStream rss;
rss << attribute;
return writeAttribute( name, rss.str() );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x71145(%rip), %rax # 0xa9f48
movq %rax, (%rsp)
callq 0x527ea
leaq 0x8(%rax), %rdi
callq 0x3737a
movq %rax, %r12
movq %rax, 0x8(%rsp)
callq 0x527ea
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %r12
movq %r1... | /olivermichel[P]libom2/test/include/catch.h |
Catch::StreamingReporterBase<Catch::XmlReporter>::StreamingReporterBase(Catch::ReporterConfig const&) | StreamingReporterBase( ReporterConfig const& _config )
: m_config( _config.fullConfig() ),
stream( _config.stream() )
{
m_reporterPrefs.shouldRedirectStdOut = false;
if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
CATCH_ERRO... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x736f6(%rip), %rax # 0xac8d8
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x3920f
movq 0x74d87(%rip), %rcx # 0xadf88
cmpb $0x0, (%rcx)
je 0x3920b
incl... | /olivermichel[P]libom2/test/include/catch.h |
Catch::clara::detail::BasicResult<void>::BasicResult(Catch::clara::detail::ResultBase::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | BasicResult( ResultBase::Type type, std::string const &message )
: ResultValueBase<T>(type),
m_errorMessage(message)
{
assert( m_type != ResultBase::Ok );
} | pushq %rbx
movq %rdi, %rbx
movl %esi, 0x8(%rdi)
leaq 0x708c8(%rip), %rax # 0xac050
movq %rax, (%rdi)
addq $0x10, %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x417c2
cmpl $0x0, 0x8(%rbx)
je 0x3b7ae
popq %rbx
retq
leaq 0x41a1c(%rip), %rdi # 0x7d1d1... | /olivermichel[P]libom2/test/include/catch.h |
Catch::clara::detail::TokenStream::loadBuffer() | void loadBuffer() {
m_tokenBuffer.resize( 0 );
// Skip any empty strings
while( it != itEnd && it->empty() )
++it;
if( it != itEnd ) {
auto const &next = *it;
if( isOptPrefix( next[0] ) ) {
auto delimit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r15
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3bd92
movq (%r15), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x3bb97
movq 0x8(%r14), %rdx
testq %rdx, %rdx
jne 0x3bac1
addq $0x20, %r14
movq %r14, (%r15)
jm... | /olivermichel[P]libom2/test/include/catch.h |
optimizeBlock | int optimizeBlock(void)
{
if (*p != '[') {
if (!parseTerm())
return 0;
parseError("missing block as optimized block argument");
} else {
p++;
skipSpaces();
if (*p == ']') {
genInstruction(PushConstant, 0);
p++;
skipSpaces();... | pushq %r15
pushq %r14
pushq %rbx
movq 0xca04(%rip), %rax # 0x131d0
cmpb $0x5b, (%rax)
jne 0x6846
incq %rax
movq %rax, 0xc9f5(%rip) # 0x131d0
callq 0x46aa
movq 0xc9e9(%rip), %rax # 0x131d0
cmpb $0x5d, (%rax)
jne 0x685b
movslq 0x1a7f5(%rip), %rax # 0x20fe8
leal 0x1(%rax), %ecx
movl %ecx, 0x1a7ec(%rip) ... | /kyle-github[P]littlesmalltalk/src/bootstrap/bootstrap.c |
fileIn | int fileIn(FILE *fp)
{
uint8_t version = get_image_version(fp);
switch(version) {
case IMAGE_VERSION_0:
info("Reading in version 0 image.");
return fileIn_version_0(fp);
break;
case IMAGE_VERSION_1:
info("Reading in version 1 image.");
return fileIn_version_1(fp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r15
callq 0x7968
movzbl %al, %ecx
cmpb $0x3, %cl
ja 0x70d1
leaq 0x62e3(%rip), %rax # 0xd37c
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x6303(%rip), %rdi # 0xd3ac
leaq 0x6357(%rip), %rdx # 0xd40... | /kyle-github[P]littlesmalltalk/src/vm/image.c |
gcialloc | struct object *gcialloc(int sz)
{
int trueSize;
struct object *result;
trueSize = TO_WORDS(sz);
result = gcalloc(trueSize);
SET_SIZE(result, sz);
SET_BINOBJ(result);
return result;
} | pushq %rbx
movl %edi, %ebx
leal 0x7(%rbx), %eax
leal 0xe(%rbx), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
movl %ecx, %edi
andl $-0x8, %ecx
movl $0xfffffff0, %eax # imm = 0xFFFFFFF0
subl %ecx, %eax
cltq
addq 0x1e5d7(%rip), %rax # 0x28a28
sarl $0x3, %edi
movq %rax, 0x1e5cd(%rip) # 0x28a28
cmpq 0x1e5be(%rip),... | /kyle-github[P]littlesmalltalk/src/vm/memory.c |
glfwPlatformCreateWindow | int _glfwPlatformCreateWindow(_GLFWwindow* window,
const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
if (!_glfwCreateContext(window, ctxconfig, fbconfig))
return GL_FALS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x111f9
testl %eax, %eax
je 0xe273
movq 0x2b8(%rbx), %r15
leaq 0xa689(%rip), %r13 # 0x186a8
movq 0xb8(%r13), %rdi
movq 0xc8(%r13), %rsi
... | /creationix[P]lit-glfw/glfw/src/x11_window.c |
glfwPlatformDestroyWindow | void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
if (window->monitor)
leaveFullscreenMode(window);
if (window->x11.ic)
{
XDestroyIC(window->x11.ic);
window->x11.ic = NULL;
}
_glfwDestroyContext(window);
if (window->x11.handle)
{
if (XGetSelectionOwner... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0xe9b0
callq 0xd6fa
leaq 0x9de5(%rip), %r15 # 0x186a8
decl 0x440(%r15)
jne 0xe8f4
movq 0xb8(%r15), %rdi
movl 0x444(%r15), %esi
movl 0x448(%r15), %edx
movl 0x44c(%r15), %ecx
m... | /creationix[P]lit-glfw/glfw/src/x11_window.c |
glfwPlatformGetWindowSize | void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
{
XWindowAttributes attribs;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
if (width)
*width = attribs.width;
if (height)
*height = attribs.height;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x9967(%rip), %rax # 0x186a8
movq 0xb8(%rax), %rax
movq 0x270(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x7af0
testq %r14, %r14
je 0xed66
movl 0x8(%rsp), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0xed71
movl 0xc(%rsp), %eax
movl %... | /creationix[P]lit-glfw/glfw/src/x11_window.c |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.