name string | code string | asm string | file string |
|---|---|---|---|
chooseEGLConfig | static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* desired,
EGLConfig* result)
{
EGLConfig* nativeConfigs;
_GLFWfbconfig* usableConfigs;
const _GLFWfbconfig* closest;
int i, nativeCount, usableCount;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0xef71(%rip), %rbp # 0x2eb78
movq 0xd10(%rbp), %rdi
leaq 0x4(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq *0xd40(%rbp)
movslq (%rbx), %rbx
testq %rbx, %rbx
je... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
makeContextCurrentEGL | static void makeContextCurrentEGL(_GLFWwindow* window)
{
if (window)
{
if (!eglMakeCurrent(_glfw.egl.display,
window->context.egl.surface,
window->context.egl.surface,
window->context.egl.handle))
{
_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xec51(%rip), %r14 # 0x2eb78
movq 0xd10(%r14), %rdi
movq 0xd90(%r14), %rax
testq %rbx, %rbx
je 0x1ff68
movq 0x280(%rbx), %rcx
movq 0x288(%rbx), %rdx
movq %rdx, %rsi
callq *%rax
testl %eax, %eax
jne 0x1ff74
callq *0xd50(%r14)
movl %eax, %edi
callq 0x1f78e
leaq 0... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
getProcAddressEGL | static GLFWglproc getProcAddressEGL(const char* procname)
{
_GLFWwindow* window = _glfwPlatformGetCurrentContext();
if (window->context.egl.client)
{
GLFWglproc proc = (GLFWglproc) _glfw_dlsym(window->context.egl.client,
procname);
if (proc... | pushq %rbx
movq %rdi, %rbx
callq 0x1e42e
movq 0x290(%rax), %rdi
testq %rdi, %rdi
je 0x2002c
movq %rbx, %rsi
callq 0x10920
testq %rax, %rax
je 0x2002c
popq %rbx
retq
leaq 0xeb45(%rip), %rax # 0x2eb78
movq %rbx, %rdi
popq %rbx
jmpq *0xdb0(%rax)
| /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
destroyContextEGL | static void destroyContextEGL(_GLFWwindow* window)
{
#if defined(_GLFW_X11)
// NOTE: Do not unload libGL.so.1 while the X11 display is still open,
// as it will make XCloseDisplay segfault
if (window->context.client != GLFW_OPENGL_API)
#endif // _GLFW_X11
{
if (window->context.egl.client)
... | pushq %rbx
movq %rdi, %rbx
cmpl $0x30001, 0x1f0(%rdi) # imm = 0x30001
je 0x20069
movq 0x290(%rbx), %rdi
testq %rdi, %rdi
je 0x20069
callq 0x10a60
movq $0x0, 0x290(%rbx)
movq 0x288(%rbx), %rsi
testq %rsi, %rsi
je 0x20094
leaq 0xeafc(%rip), %rax # 0x2eb78
movq 0xd10(%rax), %rdi
callq *0xd78(%rax)
movq $0x0, 0x288(... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
glfwChooseVisualEGL | GLFWbool _glfwChooseVisualEGL(const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
XVisualInfo* result;
XVisualInfo desired;
EGLConfig native;
EGLint visualID = 0, count = 0;
const long vimask = Vis... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdx, %r14
xorl %ebp, %ebp
movl %ebp, 0x4(%rsp)
movl %ebp, (%rsp)
leaq 0x8(%rsp), %rdx
callq 0x1fbe9
testl %eax, %eax
je 0x2015e
leaq 0xea87(%rip), %r12 # 0x2eb78
movq 0xd10(%r12), %rdi
movq 0x8(%rsp), %rsi
leaq 0x4(%rsp),... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
glfwGetEGLContext | GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_CONTEXT);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_CONTEXT;
}
return wind... | pushq %rbx
leaq 0xe99e(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x201e1
cmpl $0x0, 0x1f0(%rdi)
je 0x201ea
movq 0x280(%rdi), %rbx
jmp 0x201fa
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x201f1
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
glfwGetEGLSurface | GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_SURFACE);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_SURFACE;
}
return wind... | pushq %rbx
leaq 0xe961(%rip), %rax # 0x2eb68
cmpl $0x0, (%rax)
je 0x2021e
cmpl $0x0, 0x1f0(%rdi)
je 0x20227
movq 0x288(%rdi), %rbx
jmp 0x20237
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2022e
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Wei-Parker-Guo[P]PhongSphere/glfw-3.2.1/src/egl_context.c |
test | int test(char *URL)
{
CURL *easy = NULL;
CURL *easy2 = NULL;
curl_mime *mime = NULL;
curl_mimepart *part;
struct curl_slist *hdrs = NULL;
CURLcode result;
int res = TEST_ERR_FAILURE;
struct WriteThis pooh;
/*
* Check proper copy/release of mime post data bound to a duplicated
* easy handle.
... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x77, -0x40(%rbp)
movl $0x3, %edi
callq 0x1170
cmpl $0x0, %eax
je 0x1316
movq 0x2ce7(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xd01(%rip), %rsi ... | /DarovskikhAndrei[P]curl/tests/libtest/lib654.c |
main | int main(int argc, char **argv)
{
char *URL;
int result;
#ifdef O_BINARY
# ifdef __HIGHC__
_setmode(stdout, O_BINARY);
# else
setmode(fileno(stdout), O_BINARY);
# endif
#endif
memory_tracking_init();
/*
* Setup proper locale from environment. This is needed to enable locale-
* specific behaviour... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x1818
movl $0x6, %edi
leaq 0x8e0(%rip), %rsi # 0x2104
callq 0x10e0
cmpl $0x2, -0x8(%rbp)
jge 0x1850
movq 0x27aa(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0x8cb(%rip), %rsi # 0x210b
movb... | /DarovskikhAndrei[P]curl/tests/libtest/first.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);
} | cmpl $0x5, %ecx
jne 0x12f3b
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 0x16a6e
movq %rax, %r12
cmpq %r15, %rax
jne 0x12f3f
cmpb $0x0, -0x1(%r14,%r15)
je 0x12f3f
pushq $0x3
popq %rax
jmp 0x12f54
pushq $0x1e
... | /nanomsg[P]nng/src/core/options.c |
nni_sock_find | int
nni_sock_find(nni_sock **sockp, uint32_t id)
{
int rv = 0;
nni_sock *s;
nni_mtx_lock(&sock_lk);
if ((s = nni_id_get(&sock_ids, id)) != NULL) {
if (s->s_closed) {
rv = NNG_ECLOSED;
} else {
s->s_ref++;
*sockp = s;
}
} else {
rv = NNG_ECLOSED;
}
nni_mtx_unlock(&sock_lk);
return (rv);
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x40b03(%rip), %rdi # 0x54be8
callq 0x171b4
movl %r14d, %esi
leaq 0x3f474(%rip), %rdi # 0x53568
callq 0x10982
pushq $0x7
popq %r14
testq %rax, %rax
je 0x14117
cmpb $0x0, 0x221(%rax)
jne 0x14117
incl 0xb0(%rax)
movq %rax, (%rb... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_open | int
nni_sock_open(nni_sock **sockp, const nni_proto *proto)
{
nni_sock *s = NULL;
int rv;
if (proto->proto_version != NNI_PROTOCOL_VERSION) {
// unsupported protocol version
return (NNG_ENOTSUP);
}
if ((rv = nni_sock_create(&s, proto)) != 0) {
return (rv);
}
nni_mtx_lock(&sock_lk);
if ((rv = nni_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x50520003, (%rsi) # imm = 0x50520003
jne 0x144b6
movq %rsi, %r15
movq %rdi, %r14
movq 0x30(%rsi), %rax
movl $0x558, %edi # imm = 0x558
addq (%rax), %rdi
callq 0x181a7
testq %rax, %rax
je 0x144ba
movq... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_shutdown | int
nni_sock_shutdown(nni_sock *sock)
{
nni_pipe *pipe;
nni_dialer *d;
nni_listener *l;
nni_ctx *ctx;
nni_ctx *nctx;
nni_mtx_lock(&sock->s_mx);
if (sock->s_closing) {
nni_mtx_unlock(&sock->s_mx);
return (NNG_ECLOSED);
}
// Mark us closing, so no more EPs or changes can occur.
sock->s_clos... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x171b4
cmpb $0x1, 0x220(%r12)
jne 0x146db
movq %r14, %rdi
callq 0x171be
pushq $0x7
popq %rax
jmp 0x1489f
movb $0x1, 0x220(%r12)
leaq 0x1c0(%r12), %rbx
movq %rbx, %rdi... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_close | void
nni_sock_close(nni_sock *s)
{
// Shutdown everything if not already done. This operation
// is idempotent.
nni_sock_shutdown(s);
nni_mtx_lock(&sock_lk);
if (s->s_closed) {
// Some other thread called close. All we need to do
// is drop our reference count.
nni_mtx_unlock(&sock_lk);
nni_sock_rele(s)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x146a3
leaq 0x402fa(%rip), %rdi # 0x54be8
callq 0x171b4
cmpb $0x1, 0x221(%rbx)
jne 0x1491a
leaq 0x402e5(%rip), %rdi # 0x54be8
callq 0x171be
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_closeall | void
nni_sock_closeall(void)
{
nni_sock *s;
for (;;) {
nni_mtx_lock(&sock_lk);
if ((s = nni_list_first(&sock_list)) == NULL) {
nni_mtx_unlock(&sock_lk);
return;
}
// Bump the reference count. The close call below
// will drop it.
s->s_ref++;
nni_list_node_remove(&s->s_node);
nni_mtx_unlock(&so... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x401ad(%rip), %rbx # 0x54be8
leaq 0x3eb5e(%rip), %r14 # 0x535a0
movq %rbx, %rdi
callq 0x171b4
movq %r14, %rdi
callq 0x111f5
testq %rax, %rax
je 0x14a7a
movq %rax, %r15
incl 0xb0(%rax)
movq %rax, %rdi
callq 0x11408
movq %rbx, %rdi
callq... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_add_listener | int
nni_sock_add_listener(nni_sock *s, nni_listener *l)
{
int rv;
// grab a hold on the listener for the socket
if ((rv = nni_listener_hold(l)) != 0) {
return (rv);
}
// copy initial values for some options from socket
for (int i = 0; ep_options[i].eo_name != NULL; i++) {
uint64_t val; // big en... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movq %rsi, %rdi
callq 0x11968
testl %eax, %eax
je 0x14ba8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, -0x30(%rbp)
pushq $0x8
popq %rbx
cmpq ... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_getopt | int
nni_sock_getopt(
nni_sock *s, const char *name, void *val, size_t *szp, nni_type t)
{
int rv;
nni_mtx_lock(&s->s_mx);
if (s->s_closing) {
nni_mtx_unlock(&s->s_mx);
return (NNG_ECLOSED);
}
// Protocol specific options. The protocol can override
// options like the send buffer or notification descrip... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r15d
movq %rcx, -0x38(%rbp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x171b4
cmpb $0x0, 0x220(%r13)
je 0x14ccc
pushq $0x7
popq %r15
jmp 0x14d18
movq 0xb8(%r13... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_remove_listener | void
nni_sock_remove_listener(nni_listener *l)
{
nni_sock *s = l->l_sock;
nni_mtx_lock(&s->s_mx);
NNI_ASSERT(nni_list_node_active(&l->l_node));
nni_list_node_remove(&l->l_node);
nni_mtx_unlock(&s->s_mx);
// also drop the hold from the socket
nni_listener_rele(l);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x90(%rdi), %r14
addq $0x10, %r14
movq %r14, %rdi
callq 0x171b4
leaq 0x80(%rbx), %r15
movq %r15, %rdi
callq 0x113f9
testl %eax, %eax
jne 0x14d86
leaq 0x244e4(%rip), %rdi # 0x39250
leaq 0x24fad(%rip), %rsi # 0x39d20
leaq ... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_add_dialer | int
nni_sock_add_dialer(nni_sock *s, nni_dialer *d)
{
int rv;
// grab a hold on the dialer for the socket
if ((rv = nni_dialer_hold(d)) != 0) {
return (rv);
}
// copy initial values for some options from socket
for (int i = 0; ep_options[i].eo_name != NULL; i++) {
uint64_t val; // big enough
co... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movq %rsi, %rdi
callq 0x1020a
testl %eax, %eax
je 0x14dda
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, -0x30(%rbp)
pushq $0x8
popq %rbx
cmpq ... | /nanomsg[P]nng/src/core/socket.c |
nni_ctx_open | int
nni_ctx_open(nni_ctx **ctxp, nni_sock *sock)
{
nni_ctx *ctx;
int rv;
size_t sz;
if (sock->s_ctx_ops.ctx_init == NULL) {
return (NNG_ENOTSUP);
}
sz = NNI_ALIGN_UP(sizeof(*ctx)) + sock->s_ctx_ops.ctx_size;
if ((ctx = nni_zalloc(sz)) == NULL) {
return (NNG_ENOMEM);
}
ctx->c_size = sz;
ctx->c... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x180(%rsi)
je 0x15205
movq %rsi, %r15
movq %rdi, %r14
leaq 0x178(%rsi), %r13
movq (%r13), %r12
addq $0x70, %r12
movq %r12, %rdi
callq 0x181a7
testq %rax, %rax
je 0x15209
movq %rax, %rbx
movq %r12, 0x50(%rax)
addq $0... | /nanomsg[P]nng/src/core/socket.c |
nni_ctx_getopt | int
nni_ctx_getopt(nni_ctx *ctx, const char *opt, void *v, size_t *szp, nni_type t)
{
nni_sock *sock = ctx->c_sock;
nni_option *o;
int rv = NNG_ENOTSUP;
nni_mtx_lock(&sock->s_mx);
if (strcmp(opt, NNG_OPT_RECVTIMEO) == 0) {
rv = nni_copyout_ms(ctx->c_rcvtimeo, v, szp, t);
} else if (strcmp(opt, NNG_OP... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r12d
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
addq $0x10, %rdi
movq %rdi, -0x30(%rbp)
callq 0x171b4
leaq 0x24ab5(%rip), %rsi # 0x39e35
movq %r14, %rdi
callq 0x9... | /nanomsg[P]nng/src/core/socket.c |
nni_ctx_setopt | int
nni_ctx_setopt(
nni_ctx *ctx, const char *opt, const void *v, size_t sz, nni_type t)
{
nni_sock *sock = ctx->c_sock;
nni_option *o;
int rv = NNG_ENOTSUP;
nni_mtx_lock(&sock->s_mx);
if (strcmp(opt, NNG_OPT_RECVTIMEO) == 0) {
rv = nni_copyin_ms(&ctx->c_rcvtimeo, v, sz, t);
} else if (strcmp(opt... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r12d
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movq 0x10(%rdi), %rdi
addq $0x10, %rdi
movq %rdi, -0x30(%rbp)
callq 0x171b4
leaq 0x249c1(%rip), %rsi # 0x39e35
movq %r14, %rdi
callq 0x9... | /nanomsg[P]nng/src/core/socket.c |
dialer_timer_start_locked | static void
dialer_timer_start_locked(nni_dialer *d)
{
nni_duration back_off;
back_off = d->d_currtime;
if (d->d_maxrtime > 0) {
d->d_currtime *= 2;
if (d->d_currtime > d->d_maxrtime) {
d->d_currtime = d->d_maxrtime;
}
}
// To minimize damage from storms, etc., we select a back-off
// value randomly, i... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x470(%rdi), %eax
movl 0x474(%rdi), %r14d
testl %eax, %eax
jle 0x15593
leal (%r14,%r14), %ecx
cmpl %eax, %ecx
cmovll %ecx, %eax
movl %eax, 0x474(%rbx)
testl %r14d, %r14d
je 0x155a6
callq 0x1a198
xorl %edx, %edx
divl %r14d
movl %edx, %edi
jmp 0x155a8
... | /nanomsg[P]nng/src/core/socket.c |
nni_dialer_shutdown | void
nni_dialer_shutdown(nni_dialer *d)
{
nni_sock *s = d->d_sock;
nni_pipe *p;
if (nni_atomic_flag_test_and_set(&d->d_closing)) {
return;
}
nni_dialer_stop(d);
nni_mtx_lock(&s->s_mx);
NNI_LIST_FOREACH (&d->d_pipes, p) {
nni_pipe_close(p);
}
nni_mtx_unlock(&s->s_mx);
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x80(%rdi), %rbx
addq $0x95, %rdi
callq 0x181d4
testb %al, %al
je 0x155ea
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x1041e
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x171b4
addq $0xc0, %r14... | /nanomsg[P]nng/src/core/socket.c |
nni_listener_reap | static void
listener_reap(void *arg)
{
nni_listener *l = arg;
nni_sock *s = l->l_sock;
#ifdef NNG_ENABLE_STATS
nni_stat_unregister(&l->st_root);
#endif
nni_mtx_lock(&s->s_mx);
if (!nni_list_empty(&l->l_pipes)) {
nni_pipe *p;
// This should already have been done, but be certain!
NNI_LIST_FOREACH (&l->l... | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rsi
leaq 0x3df39(%rip), %rdi # 0x53618
popq %rbp
jmp 0x13a24
| /nanomsg[P]nng/src/core/socket.c |
nni_pipe_run_cb | void
nni_pipe_run_cb(nni_pipe *p, nng_pipe_ev ev)
{
nni_sock *s = p->p_sock;
nng_pipe_cb cb;
void *arg;
bool wantevs;
static nni_mtx serialize = NNI_MTX_INITIALIZER;
nni_mtx_lock(&s->s_pipe_cbs_mtx);
cb = s->s_pipe_cbs[ev].cb_fn;
arg = s->s_pipe_cbs[ev].cb_arg;
wantevs = s-... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0xb8(%rdi), %r15
leaq 0x228(%r15), %r12
movq %r12, %rdi
callq 0x171b4
movl %ebx, %eax
shlq $0x4, %rax
movq 0x250(%r15,%rax), %r13
movq 0x258(%r15,%rax), %rax
movq %rax, -0x30(%rbp)
movb 0x29... | /nanomsg[P]nng/src/core/socket.c |
nni_pipe_remove | void
nni_pipe_remove(nni_pipe *p)
{
nni_sock *s = p->p_sock;
nni_dialer *d = p->p_dialer;
nni_mtx_lock(&s->s_mx);
#ifdef NNG_ENABLE_STATS
nni_stat_dec(&s->st_pipes, 1);
if (p->p_listener != NULL) {
nni_stat_dec(&p->p_listener->st_pipes, 1);
}
if (p->p_dialer != NULL) {
nni_stat_dec(&p->p_dialer->st_pipes,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r12
movq 0xb8(%rdi), %r14
movq 0xc0(%rdi), %r15
leaq 0x10(%r14), %rbx
movq %rbx, %rdi
callq 0x171b4
leaq 0x3d8(%r14), %rdi
pushq $0x1
popq %rsi
callq 0x1618c
movq 0xc8(%r12), %rdi
testq %rdi, %rdi
je 0x15c3e
addq $0x5d8, %rdi ... | /nanomsg[P]nng/src/core/socket.c |
nni_sock_add_stat | void
nni_sock_add_stat(nni_sock *s, nni_stat_item *stat)
{
#ifdef NNG_ENABLE_STATS
nni_stat_add(&s->st_root, stat);
#else
NNI_ARG_UNUSED(s);
NNI_ARG_UNUSED(stat);
#endif
} | pushq %rbp
movq %rsp, %rbp
addq $0x298, %rdi # imm = 0x298
popq %rbp
jmp 0x16030
| /nanomsg[P]nng/src/core/socket.c |
nni_sock_bump_rx | void
nni_sock_bump_rx(nni_sock *s, uint64_t sz)
{
#ifdef NNG_ENABLE_STATS
nni_stat_inc(&s->st_rx_msgs, 1);
nni_stat_inc(&s->st_rx_bytes, sz);
#else
NNI_ARG_UNUSED(s);
NNI_ARG_UNUSED(sz);
#endif
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x498, %rdi # imm = 0x498
pushq $0x1
popq %rsi
callq 0x1616f
addq $0x418, %r14 # imm = 0x418
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1616f
| /nanomsg[P]nng/src/core/socket.c |
dialer_reap | static void
dialer_reap(void *arg)
{
nni_dialer *d = arg;
nni_sock *s = d->d_sock;
#ifdef NNG_ENABLE_STATS
nni_stat_unregister(&d->st_root);
#endif
nni_mtx_lock(&s->s_mx);
if (!nni_list_empty(&d->d_pipes)) {
nni_pipe *p;
// This should already have been done, but be certain!
NNI_LIST_FOREACH (&d->d_pipes... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %r12
addq $0x550, %rdi # imm = 0x550
callq 0x160f3
leaq 0x10(%r12), %r14
movq %r14, %rdi
callq 0x171b4
leaq 0xc0(%rbx), %r15
movq %r15, %rdi
callq 0x113df
testl %eax, %eax
je 0x15f3f
movq %r14, %rdi
callq ... | /nanomsg[P]nng/src/core/socket.c |
listener_reap | static void
listener_reap(void *arg)
{
nni_listener *l = arg;
nni_sock *s = l->l_sock;
#ifdef NNG_ENABLE_STATS
nni_stat_unregister(&l->st_root);
#endif
nni_mtx_lock(&s->s_mx);
if (!nni_list_empty(&l->l_pipes)) {
nni_pipe *p;
// This should already have been done, but be certain!
NNI_LIST_FOREACH (&l->l... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %r12
addq $0x518, %rdi # imm = 0x518
callq 0x160f3
leaq 0x10(%r12), %r14
movq %r14, %rdi
callq 0x171b4
leaq 0xa0(%rbx), %r15
movq %r15, %rdi
callq 0x113df
testl %eax, %eax
je 0x15fe9
leaq 0x80(%rbx), %rdi
... | /nanomsg[P]nng/src/core/socket.c |
nni_stat_add | void
nni_stat_add(nni_stat_item *parent, nni_stat_item *child)
{
#ifdef NNG_ENABLE_STATS
// Make sure that the lists for both children and parents
// are correctly initialized.
if (parent->si_children.ll_head.ln_next == NULL) {
NNI_LIST_INIT(&parent->si_children, nni_stat_item, si_node);
}
if (child->si_children... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x10(%rdi), %r14
cmpq $0x0, 0x10(%rdi)
jne 0x1604f
movq %r14, %rdi
xorl %esi, %esi
callq 0x111e4
cmpq $0x0, 0x10(%rbx)
jne 0x16061
leaq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0x111e4
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0... | /nanomsg[P]nng/src/core/stats.c |
nni_stat_register | void
nni_stat_register(nni_stat_item *child)
{
#ifdef NNG_ENABLE_STATS
nni_mtx_lock(&stats_lock);
nni_stat_add(&stats_root, child);
nni_mtx_unlock(&stats_lock);
#else
NNI_ARG_UNUSED(child);
#endif
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3ebbf(%rip), %r14 # 0x54c40
movq %r14, %rdi
callq 0x171b4
leaq 0x3d5b0(%rip), %rdi # 0x53640
movq %rbx, %rsi
callq 0x16030
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x171be
| /nanomsg[P]nng/src/core/stats.c |
nni_stat_unregister | void
nni_stat_unregister(nni_stat_item *item)
{
#ifdef NNG_ENABLE_STATS
nni_mtx_lock(&stats_lock);
stat_unregister(item);
nni_mtx_unlock(&stats_lock);
#else
NNI_ARG_UNUSED(item);
#endif
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3eb3c(%rip), %r14 # 0x54c40
movq %r14, %rdi
callq 0x171b4
movq %rbx, %rdi
callq 0x160a4
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x171be
| /nanomsg[P]nng/src/core/stats.c |
nni_stat_dec | void
nni_stat_dec(nni_stat_item *item, uint64_t inc)
{
#ifdef NNG_ENABLE_STATS
if (item->si_info->si_atomic) {
nni_atomic_sub64(&item->si_u.sv_atomic, inc);
} else {
item->si_u.sv_number -= inc;
}
#else
NNI_ARG_UNUSED(item);
NNI_ARG_UNUSED(inc);
#endif
} | pushq %rbp
movq %rsp, %rbp
movq 0x28(%rdi), %rax
addq $0x38, %rdi
testb $0x1, 0x18(%rax)
je 0x161a4
popq %rbp
jmp 0x182b9
subq %rsi, (%rdi)
popq %rbp
retq
| /nanomsg[P]nng/src/core/stats.c |
nni_stat_set_string | void
nni_stat_set_string(nni_stat_item *item, const char *s)
{
#ifdef NNG_ENABLE_STATS
const nni_stat_info *info = item->si_info;
char *old = item->si_u.sv_string;
nni_mtx_lock(&stats_val_lock);
if ((s != NULL) && (old != NULL) && (strcmp(s, old) == 0)) {
// no change
nni_mtx_unlock(&stats_val_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rdi), %r12
movq 0x38(%rdi), %rbx
leaq 0x3ea8c(%rip), %rdi # 0x54c68
callq 0x171b4
testq %r15, %r15
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x16203
movq %r15, %rdi
movq %rbx... | /nanomsg[P]nng/src/core/stats.c |
nng_stats_free | void
nng_stats_free(nni_stat *st)
{
#ifdef NNG_ENABLE_STATS
nni_stat *child;
while ((child = nni_list_first(&st->s_children)) != NULL) {
nni_list_remove(&st->s_children, child);
nng_stats_free(child);
}
if (st->s_info->si_alloc) {
nni_strfree(st->s_val.sv_string);
}
NNI_FREE_STRUCT(st);
#else
NNI_ARG_UNUS... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0x111f5
testq %rax, %rax
je 0x1629e
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x113aa
movq %r15, %rdi
callq 0x16268
jmp 0x16279
movq (%rbx), %rax
testb $0x2, 0x18(%rax)
je 0x162... | /nanomsg[P]nng/src/core/stats.c |
stat_make_tree | static int
stat_make_tree(nni_stat_item *item, nni_stat **sp)
{
nni_stat *stat;
nni_stat_item *child;
if ((stat = NNI_ALLOC_STRUCT(stat)) == NULL) {
return (NNG_ENOMEM);
}
NNI_LIST_INIT(&stat->s_children, nni_stat, s_node);
stat->s_info = item->si_info;
stat->s_item = item;
stat->s_parent = NULL;
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x50
popq %rdi
callq 0x181a7
testq %rax, %rax
je 0x163e8
movq %rax, %r15
movq %rbx, -0x30(%rbp)
movq %rax, %r12
addq $0x10, %r12
pushq $0x30
popq %rsi
movq %r12, %rdi
callq 0x111e4
m... | /nanomsg[P]nng/src/core/stats.c |
nng_stats_get | int
nng_stats_get(nng_stat **statp)
{
#ifdef NNG_ENABLE_STATS
return (nni_stat_snapshot(statp, &stats_root));
#else
NNI_ARG_UNUSED(statp);
return (NNG_ENOTSUP);
#endif
} | pushq %rbp
movq %rsp, %rbp
leaq 0x3d087(%rip), %rsi # 0x53640
popq %rbp
jmp 0x162c5
| /nanomsg[P]nng/src/core/stats.c |
nng_stat_next | const nng_stat *
nng_stat_next(const nng_stat *stat)
{
#if NNG_ENABLE_STATS
if (stat->s_parent == NULL) {
return (NULL); // Root node, no siblings.
}
return (nni_list_next(&stat->s_parent->s_children, (void *) stat));
#else
NNI_ARG_UNUSED(stat);
return (NULL);
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, %rsi
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x165e3
addq $0x10, %rdi
popq %rbp
jmp 0x11361
xorl %eax, %eax
popq %rbp
retq
| /nanomsg[P]nng/src/core/stats.c |
nng_stat_child | const nng_stat *
nng_stat_child(const nng_stat *stat)
{
#if NNG_ENABLE_STATS
return (nni_list_first(&stat->s_children));
#else
NNI_ARG_UNUSED(stat);
return (NULL);
#endif
} | pushq %rbp
movq %rsp, %rbp
addq $0x10, %rdi
popq %rbp
jmp 0x111f5
| /nanomsg[P]nng/src/core/stats.c |
nng_stat_name | const char *
nng_stat_name(const nng_stat *stat)
{
#if NNG_ENABLE_STATS
return (stat->s_info->si_name);
#else
NNI_ARG_UNUSED(stat);
return (NULL);
#endif
} | pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq (%rax), %rax
popq %rbp
retq
| /nanomsg[P]nng/src/core/stats.c |
nng_stat_value | uint64_t
nng_stat_value(const nng_stat *stat)
{
#if NNG_ENABLE_STATS
return (stat->s_val.sv_value);
#else
NNI_ARG_UNUSED(stat);
return (0);
#endif
} | pushq %rbp
movq %rsp, %rbp
movq 0x48(%rdi), %rax
popq %rbp
retq
| /nanomsg[P]nng/src/core/stats.c |
nng_stat_bool | bool
nng_stat_bool(const nng_stat *stat)
{
#if NNG_ENABLE_STATS
return (stat->s_val.sv_bool);
#else
NNI_ARG_UNUSED(stat);
return (false);
#endif
} | pushq %rbp
movq %rsp, %rbp
movb 0x48(%rdi), %al
popq %rbp
retq
| /nanomsg[P]nng/src/core/stats.c |
nni_plat_udp_multicast_membership | int
nni_plat_udp_multicast_membership(
nni_plat_udp *udp, nni_sockaddr *sa, bool join)
{
struct sockaddr_storage ss;
socklen_t sz;
int rv;
sz = nni_posix_nn2sockaddr(&ss, sa);
if (sz < 1) {
return (NNG_EADDRINVAL);
}
switch (ss.ss_family) {
case AF_INET:
rv = ip4_multi... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edx, %r14d
movq %rdi, %r15
leaq -0x130(%rbp), %rdi
callq 0x18ce0
pushq $0xf
popq %rbx
testl %eax, %eax
je 0x19ab1
movzwl -0x130(%rbp), %eax
cmpl $0xa, %eax
je 0x19a3d
cmpl $0x2, %eax
jne 0x19ab1
leaq -0x1c(%rbp)... | /nanomsg[P]nng/src/platform/posix/posix_udp.c |
nni_posix_udp_doerror | static void
nni_posix_udp_doerror(nni_plat_udp *udp, int rv)
{
nni_aio *aio;
while (((aio = nni_list_first(&udp->udp_recvq)) != NULL) ||
((aio = nni_list_first(&udp->udp_sendq)) != NULL)) {
nni_aio_list_remove(aio);
nni_aio_finish_error(aio, rv);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x58(%rdi), %r15
addq $0x40, %r14
movq %r14, %rdi
callq 0x111f5
testq %rax, %rax
jne 0x19af3
movq %r15, %rdi
callq 0x111f5
testq %rax, %rax
je 0x19b0a
movq %rax, %r12
movq %rax, %rdi
callq 0xf0cd
movq %r12, %rdi
... | /nanomsg[P]nng/src/platform/posix/posix_udp.c |
nni_posix_pfd_init | void
nni_posix_pfd_init(nni_posix_pfd *pfd, int fd, nni_posix_pfd_cb cb, void *arg)
{
nni_posix_pollq *pq;
pq = &nni_epoll_pqs[fd % nni_epoll_npq];
(void) fcntl(fd, F_SETFD, FD_CLOEXEC);
(void) fcntl(fd, F_SETFL, O_NONBLOCK);
nni_atomic_init(&pfd->events);
nni_atomic_flag_reset(&pfd->stopped);
nni_atomic_flag... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
movl %esi, %eax
cltd
idivl 0x3b2d1(%rip) # 0x54e08
movslq %edx, %rax
imulq $0x120, %rax, %r13 # imm = 0x120
addq 0x3b2b8(%rip), %r13 # 0x54e00
... | /nanomsg[P]nng/src/platform/posix/posix_pollq_epoll.c |
pair1_get_send_buf_len | static int
pair1_get_send_buf_len(void *arg, void *buf, size_t *szp, nni_opt_type t)
{
pair1_sock *s = arg;
int val;
nni_mtx_lock(&s->mtx);
val = (int) nni_lmq_cap(&s->wmq);
nni_mtx_unlock(&s->mtx);
return (nni_copyout_int(val, buf, szp, t));
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rdi), %r13
movq %r13, %rdi
callq 0x171b4
addq $0x48, %r12
movq %r12, %rdi
callq 0x1edad
movq %rax, %r12
movq %r13, %rdi
callq 0x171be
movl %r12d, %edi
m... | /nanomsg[P]nng/src/sp/protocol/pair1/pair.c |
sfd_tran_pipe_send_cancel | static void
sfd_tran_pipe_send_cancel(nni_aio *aio, void *arg, int rv)
{
sfd_tran_pipe *p = arg;
nni_mtx_lock(&p->mtx);
if (!nni_aio_list_active(aio)) {
nni_mtx_unlock(&p->mtx);
return;
}
// If this is being sent, then cancel the pending transfer.
// The callback on the txaio will cause the user aio to
// b... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x600(%rsi), %r14
movq %r14, %rdi
callq 0x171b4
movq %r15, %rdi
callq 0xf0de
testl %eax, %eax
je 0x20797
leaq 0x88(%r12), %rdi
callq 0x111f5
cmpq %r15, %rax
je 0x20786
movq %r15, %rdi
callq 0xf0cd... | /nanomsg[P]nng/src/sp/transport/socket/sockfd.c |
sfd_tran_pipe_recv_cancel | static void
sfd_tran_pipe_recv_cancel(nni_aio *aio, void *arg, int rv)
{
sfd_tran_pipe *p = arg;
nni_mtx_lock(&p->mtx);
if (!nni_aio_list_active(aio)) {
nni_mtx_unlock(&p->mtx);
return;
}
// If receive in progress, then cancel the pending transfer.
// The callback on the rxaio will cause the user aio to
// ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x600(%rsi), %r14
movq %r14, %rdi
callq 0x171b4
movq %r15, %rdi
callq 0xf0de
testl %eax, %eax
je 0x20817
leaq 0x70(%r12), %rdi
callq 0x111f5
cmpq %r15, %rax
je 0x20806
movq %r15, %rdi
callq 0xf0cd... | /nanomsg[P]nng/src/sp/transport/socket/sockfd.c |
inproc_ep_connect | static void
inproc_ep_connect(void *arg, nni_aio *aio)
{
inproc_ep *ep = arg;
inproc_ep *server;
nni_aio_reset(aio);
nni_mtx_lock(&nni_inproc.mx);
// Find a server.
NNI_LIST_FOREACH (&nni_inproc.servers, server) {
if (strcmp(server->addr, ep->addr) == 0) {
break;
}
}
if (server == NULL) {
nni_mtx_un... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xecb9
leaq 0x33224(%rip), %rdi # 0x53ac8
callq 0x171b4
leaq 0x33240(%rip), %r12 # 0x53af0
movq %r12, %rdi
callq 0x111f5
movq %rax, %r15
testq %rax, %rax
je 0x208dc
movq (%r15), %rdi
movq... | /nanomsg[P]nng/src/sp/transport/inproc/inproc.c |
inproc_ep_close | static void
inproc_ep_close(void *arg)
{
inproc_ep *ep = arg;
inproc_ep *client;
nni_aio *aio;
nni_mtx_lock(&nni_inproc.mx);
if (nni_list_active(&nni_inproc.servers, ep)) {
nni_list_remove(&nni_inproc.servers, ep);
}
// Notify any waiting clients that we are closed.
while ((client = nni_list_first(&ep->cli... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x33168(%rip), %rdi # 0x53ac8
callq 0x171b4
leaq 0x33184(%rip), %rdi # 0x53af0
movq %rbx, %rsi
callq 0x113cb
testl %eax, %eax
je 0x20987
leaq 0x33171(%rip), %rdi # 0x53af0
movq %rbx, %rsi
callq ... | /nanomsg[P]nng/src/sp/transport/inproc/inproc.c |
sdf_tools::evaluateAtGridPoints(sdf_tools::sdf::Sdf const*, sdf_tools::Grid*) | void evaluateAtGridPoints(const sdf::Sdf *sdf, Grid *grid)
{
auto applySdf = [sdf](real3 r, real& gridValue) {gridValue = sdf->at(r);};
gridForEachPoint(applySdf, grid);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xfcbe
movq %rax, %r14
movl %edx, %r12d
movq %r15, %rdi
callq 0xfcde
movaps %xmm0, 0x40(%rsp)
movss %xmm1, 0x10(%rsp)
movq %r15, %rdi
callq 0xfcd2
movss %xmm1, 0xc(%rsp)
movaps 0x40(%... | /amlucas[P]sdfTools/src/sdf_tools/core/apply_sdf.cpp |
pybind11::tuple pybind11::make_tuple<(pybind11::return_value_policy)1, pybind11::str&>(pybind11::str&) | tuple make_tuple(Args&&... args_) {
constexpr size_t size = sizeof...(Args);
std::array<object, size> args {
{ reinterpret_steal<object>(detail::make_caster<Args>::cast(
std::forward<Args>(args_), policy, nullptr))... }
};
for (size_t i = 0; i < args.size(); i++) {
if (!args[... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x1540d
incq (%rax)
movq (%rsi), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x1545c
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1563c
movq (%rsp), %rax
movq $0x0, (%rsp)
movq (%rbx), %rcx
movq 0x8(%rcx), %rdx
... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::cast<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 0>(pybind11::handle const&) | T cast(const handle &handle) {
using namespace detail;
static_assert(!cast_is_temporary_value_reference<T>::value,
"Unable to cast type to reference: value is local to type caster");
return cast_op<T>(load_type<T>(handle));
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1674a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x16730
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x16736
movups (%rdx), %xmm0
movups %xmm0... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::gil_scoped_acquire::dec_ref() | PYBIND11_NOINLINE void dec_ref() {
--tstate->gilstate_counter;
#if !defined(NDEBUG)
if (detail::get_thread_state_unchecked() != tstate)
pybind11_fail("scoped_acquire::dec_ref(): thread state must be current!");
if (tstate->gilstate_counter < 0)
pyb... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
decl 0xa0(%rax)
callq 0xbda0
movq (%rbx), %rdi
cmpq %rdi, %rax
jne 0x16d16
cmpl $0x0, 0xa0(%rdi)
js 0x16d22
jne 0x16d14
cmpb $0x0, 0x8(%rbx)
je 0x16d2e
callq 0xbe80
cmpb $0x1, 0x9(%rbx)
jne 0x16cfd
callq 0xb1b0
callq 0x14436
movq 0x1c8(%rax), %rdi
xorl %esi, %esi
callq 0xbaa... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/gil.h |
pybind11::cpp_function::strdup_guard::operator()(char const*) | char *operator()(const char *s) {
auto t = strdup(s);
strings.push_back(t);
return t;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xbea0
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x19e5b
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x19e68
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xb9c0
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
| /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::detail::instance::get_value_and_holder(pybind11::detail::type_info const*, bool) | PYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) {
// Optimize common case:
if (!find_type || Py_TYPE(this) == find_type->type)
return value_and_holder(this, find_type, 0, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1c973
movq 0x8(%rbx), %rdi
cmpq (%r15), %rdi
je 0x1c973
movl %ecx, %ebp
leaq 0xf8(%rsp), %r12
movq %rbx, (%r12)
callq 0x17a76
movq %rax, 0x8(... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/type_caster_base.h |
pybind11::detail::traverse_offset_bases(void*, pybind11::detail::type_info const*, pybind11::detail::instance*, bool (*)(void*, pybind11::detail::instance*)) | inline void traverse_offset_bases(void *valueptr, const detail::type_info *tinfo, instance *self,
bool (*f)(void * /*parentptr*/, instance * /*self*/)) {
for (handle h : reinterpret_borrow<tuple>(tinfo->type->tp_bases)) {
if (auto parent_tinfo = get_type_info((PyTypeObject *) h.ptr())) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rax
movq 0x150(%rax), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x1f0db
incq (%rax)
movq (%rsp), %r14
movq 0x8(%r14), %rax
addq $0x18, %r14
testb $... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/class.h |
sdf_tools::exportGrid(pybind11::module_&) | void exportGrid(py::module& m)
{
py::class_<Grid> (m, "Uniform", R"(
container to hold SDF grid data
)")
.def(py::init <int3, real3, real3> (),
"dimensions"_a, "offsets"_a, "extents"_a, R"(
Create an empty uniform grid of given size.
Args:
d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq (%rdi), %rsi
leaq 0x1d551(%rip), %rdx # 0x3cd68
leaq 0x1d552(%rip), %rcx # 0x3cd70
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x201be
leaq 0x1d56d(%rip), %rax # 0x3cd9f
leaq 0xb8(%rsp), %r8
movq %rax, (%r8)
movb $0x2, %... | /amlucas[P]sdfTools/src/sdf_tools/bindings/grid.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() | static std::string type_id() {
std::string name(typeid(T).name());
detail::clean_type_id(name);
return name;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq 0x33203(%rip), %rsi # 0x52f60
leaq 0x34(%rsi), %rdx
callq 0xb250
movq %rbx, %rdi
callq 0x156b7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1fd8d
movq (%r15), %r... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/typeid.h |
pybind11::class_<sdf_tools::Grid>::init_holder(pybind11::detail::instance*, pybind11::detail::value_and_holder&, std::unique_ptr<sdf_tools::Grid, std::default_delete<sdf_tools::Grid>> const*, void const*) | static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
if (holder_ptr) {
init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
... | testq %rdx, %rdx
je 0x20d71
movq 0x18(%rsi), %rax
movq (%rdx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, (%rdx)
jmp 0x20d82
testb $0x1, 0x30(%rdi)
je 0x20d99
movq 0x18(%rsi), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movq (%rsi), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x20d9a
movq 0x18(%rax), %rax
movq 0x8(%rsi), %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::detail::type_caster<char, void>::cast(char const*, pybind11::return_value_policy, pybind11::handle) | static handle cast(const CharT *src, return_value_policy policy, handle parent) {
if (src == nullptr) return pybind11::none().inc_ref();
return StringCaster::cast(StringType(src), policy, parent);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x21fa6
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0xb2a0
leaq (%rax,%r14), %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb250
movzbl %bpl, %esi
movq %r15, %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11_getbuffer | inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int flags) {
// Look for a `get_buffer` implementation in this type's info or any bases (following MRO).
type_info *tinfo = nullptr;
for (auto type : reinterpret_borrow<tuple>(Py_TYPE(obj)->tp_mro)) {
tinfo = get_type_info((PyTypeObject *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x158(%rax), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x222bd
incq (%rax)
movq (%rsp), %r13
movq 0x8(%r13), %rax
addq $0x18, %r13
testb $0x2, 0xab(%rax)
je 0x222d6
mov... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/class.h |
pybind11::detail::type_caster_generic::try_implicit_casts(pybind11::handle, bool) | bool try_implicit_casts(handle src, bool convert) {
for (auto &cast : typeinfo->implicit_casts) {
type_caster_generic sub_caster(*cast.first);
if (sub_caster.load(src, convert)) {
value = cast.second(sub_caster.value);
return true;
}
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq 0x58(%rax), %r13
movq 0x60(%rax), %rbx
cmpq %rbx, %r13
setne %bpl
je 0x23218
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq (%r13), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x2333a
movzbl %r15b,... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/type_caster_base.h |
pybind11::detail::loader_life_support::add_patient(pybind11::handle) | PYBIND11_NOINLINE static void add_patient(handle h) {
auto &stack = get_internals().loader_patient_stack;
if (stack.empty())
throw cast_error("When called outside a bound function, py::cast() cannot "
"do Python -> C++ conversions which require the creation "
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x14436
movq 0x198(%rax), %r14
cmpq %r14, 0x190(%rax)
je 0x2329f
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x23268
movq %rbx, %rsi
callq 0xb3c0
cmpl $-0x1, %eax
jne 0x23297
leaq 0x1a467(%rip), %rdi # 0x3d6ca
callq 0x14b04
movl $0x1, %edi
callq 0xb5c0
movq %rax,... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/type_caster_base.h |
pybind11::class_<sdf_tools::Grid>& pybind11::class_<sdf_tools::Grid>::def<void pybind11::detail::initimpl::constructor<sdf_tools::int3, sdf_tools::real3, sdf_tools::real3>::execute<pybind11::class_<sdf_tools::Grid>, pybind11::arg, pybind11::arg, pybind11::arg, char [242], 0>(pybind11::class_<sdf_tools::Grid>&, pybind11... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x2fb14(%rip), %r15 # 0x52ec8
movq %r15, 0x10(%rsp)
incq (%r15)
ca... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::detail::add_class_method(pybind11::object&, char const*, pybind11::cpp_function const&) | inline void add_class_method(object& cls, const char *name_, const cpp_function &cf) {
cls.attr(cf.name()) = cf;
if (strcmp(name_, "__eq__") == 0 && !cls.attr("__dict__").contains("__hash__")) {
cls.attr("__hash__") = none();
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x23e9a
movq (%r15), %rax
movq (%rbx), %rcx
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x2350f
incq (%rax)
leaq 0x18(%rsp), %r15
movq %r... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::argument_loader<pybind11::detail::value_and_holder&, sdf_tools::int3, sdf_tools::real3, sdf_tools::real3>::load_impl_sequence<0ul, 1ul, 2ul, 3ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
movq %rsi, 0x48(%rdi)
addq $0x30, %rdi
movq 0x8(%rax), %rsi
andl $0x2, %edx
shrl %edx
callq 0x22d2c
testb %al, %al
je 0x238a9
leaq 0x18(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::cpp_function::name() const | object name() const { return attr("__name__"); } | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x20(%rsp), %r14
movq %rax, -0x10(%r14)
leaq 0x17bf5(%rip), %rax # 0x3baac
movq %rax, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x1663c
movq (%rax), %rax
movq %rax, (%rbx)
testq %rax, %rax
je 0x23eda
incq (%rax)
movq %r14, %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<pybind11::cpp_function::cpp_function<void, sdf_tools::Grid, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::arg, char [291]>(void (sdf_tools::Grid::*)(std::__cxx11::basic_stri... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
// The unique_ptr makes sure nothing is leaked ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18208
movq (%r14), %r14
movups (%rbp), %xmm0
movups %xmm0, 0x38(%r14)
leaq 0x7f(%rip), %rax # 0x248f6
... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<pybind11::cpp_function::cpp_function<void, sdf_tools::Grid, float, float, int, pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::arg, pybind11::arg, pybind11::arg, char [235]>(void (sdf_tools::Grid::*)(float, float, int), pybind11::name const&, pybind11::is_method... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
// The unique_ptr makes sure nothing is leaked ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rsp, %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x18208
movq (%rbp), %rax
movups (%r13), %xmm0
movups %xmm0, 0x38(%rax)
leaq 0xd6(%rip), %rcx # 0x24b66
... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::detail::type_caster<float, void>::load(pybind11::handle, bool) | static typename std::enable_if<!std::is_floating_point<U>::value && std::is_unsigned<U>::value && (sizeof(U) <= sizeof(unsigned long)), handle>::type
cast(U src, return_value_policy /* policy */, handle /* parent */) {
return PYBIND11_LONG_FROM_UNSIGNED((unsigned long) src);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x24d3c
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testb %bpl, %bpl
jne 0x24cd1
movq 0x8(%r14), %rdi
cmpq 0x2e2f1(%rip), %rdi # 0x52fb0
je 0x24cd1
movq 0x2e2e8(%rip), %rsi # 0x52fb0
callq 0xb280
testl %eax, %eax
je 0x24d3c
movq %r14, %rd... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
sdf_tools::exportSdf(pybind11::module_&) | void exportSdf(py::module& m)
{
py::shared_class<Sdf> pysdf(m, "Sdf", R"(
Base sdf class.
)");
pysdf.def("at", &Sdf::at,
"r"_a, R"(
Evaluate the SDF field at the given position.
Args:
r: The position where to evaluate the SDF.
)");
py::shared_clas... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0x17be0(%rip), %rdx # 0x3ca62
leaq 0x18c5e(%rip), %rcx # 0x3dae7
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2583e
leaq 0x58(%rsp), %rdx
movq $0x11, (%rdx)
movq $0x0, 0x8(%rdx)
leaq 0x1948... | /amlucas[P]sdfTools/src/sdf_tools/bindings/sdf.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>() | static std::string type_id() {
std::string name(typeid(T).name());
detail::clean_type_id(name);
return name;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq 0x2d914(%rip), %rsi # 0x52f60
leaq 0x34(%rsi), %rdx
callq 0xb250
movq %rbx, %rdi
callq 0x156b7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2567c
movq (%r15), %r... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/typeid.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<bool>() | static std::string type_id() {
std::string name(typeid(T).name());
detail::clean_type_id(name);
return name;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x2d896(%rip), %rax # 0x52f28
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0xbd90
movq %rbx, %rdi
callq 0x156b7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), ... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/typeid.h |
pybind11::class_<sdf_tools::sdf::SdfCapsule, std::shared_ptr<sdf_tools::sdf::SdfCapsule>>::class_<pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>>, char [58]>(pybind11::handle, char const*, pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>> const&, char const (&) [58]... | class_(handle scope, const char *name, const Extra &... extra) {
using namespace detail;
// MI can only be specified via class_ template options, not constructor parameters
static_assert(
none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
( conste... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq $0x0, (%rdi)
movq %rsp, %rdi
callq 0x2065a
leaq 0x48(%rsp), %r14
movq %rbp, -0x48(%r14)
movq %r13, -0x40(%r14)
leaq 0x2c36c(%rip), %rax # 0x51e58
mov... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfEdges, std::shared_ptr<sdf_tools::sdf::SdfEdges>>::class_<pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>>, char [65]>(pybind11::handle, char const*, pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>> const&, char const (&) [65]) | class_(handle scope, const char *name, const Extra &... extra) {
using namespace detail;
// MI can only be specified via class_ template options, not constructor parameters
static_assert(
none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
( conste... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq $0x0, (%rdi)
movq %rsp, %rdi
callq 0x2065a
leaq 0x48(%rsp), %r14
movq %rbp, -0x48(%r14)
movq %r13, -0x40(%r14)
leaq 0x2c442(%rip), %rax # 0x51ff8
mov... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::arg_v::~arg_v() | arg_v(arg &&base, T &&x, const char *descr = nullptr)
: arg(base),
value(reinterpret_steal<object>(
detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
)),
descr(descr)
#if !defined(NDEBUG)
, type(type_id<T>())
#endif
{
// Workaroun... | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x25c5c
movq (%rax), %rsi
incq %rsi
callq 0xb800
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x149d2
nop
| /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::class_<sdf_tools::sdf::SdfSphere, std::shared_ptr<sdf_tools::sdf::SdfSphere>>::class_<pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>>, char [56]>(pybind11::handle, char const*, pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>> const&, char const (&) [56]) | class_(handle scope, const char *name, const Extra &... extra) {
using namespace detail;
// MI can only be specified via class_ template options, not constructor parameters
static_assert(
none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
( conste... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq $0x0, (%rdi)
movq %rsp, %rdi
callq 0x2065a
leaq 0x48(%rsp), %r14
movq %rbp, -0x48(%r14)
movq %r13, -0x40(%r14)
leaq 0x2c1f0(%rip), %rax # 0x520f8
mov... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfSmoothUnion, std::shared_ptr<sdf_tools::sdf::SdfSmoothUnion>>::class_<pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>>, char [38]>(pybind11::handle, char const*, pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>> const&, char const ... | class_(handle scope, const char *name, const Extra &... extra) {
using namespace detail;
// MI can only be specified via class_ template options, not constructor parameters
static_assert(
none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
( conste... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq $0x0, (%rdi)
movq %rsp, %rdi
callq 0x2065a
leaq 0x48(%rsp), %r14
movq %rbp, -0x48(%r14)
movq %r13, -0x40(%r14)
leaq 0x2bd68(%rip), %rax # 0x51f98
mov... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfComplement, std::shared_ptr<sdf_tools::sdf::SdfComplement>>::class_<pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>>, char [31]>(pybind11::handle, char const*, pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>> const&, char const (&... | class_(handle scope, const char *name, const Extra &... extra) {
using namespace detail;
// MI can only be specified via class_ template options, not constructor parameters
static_assert(
none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
( conste... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
movq $0x0, (%rdi)
movq %rsp, %rdi
callq 0x2065a
leaq 0x48(%rsp), %r14
movq %rbp, -0x48(%r14)
movq %r13, -0x40(%r14)
leaq 0x2be7e(%rip), %rax # 0x52178
mov... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd20
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x264b9
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x264bc
shrb $0x2, %al
movq 0x18(%rbx), %rcx
testb $0x1, %al
j... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfBox, std::shared_ptr<sdf_tools::sdf::SdfBox>>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd20
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x26997
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x2699a
shrb $0x2, %al
movq 0x18(%rbx), %rcx
testb $0x1, %al
j... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfBox, std::shared_ptr<sdf_tools::sdf::SdfBox>>& pybind11::class_<sdf_tools::sdf::SdfBox, std::shared_ptr<sdf_tools::sdf::SdfBox>>::def<void pybind11::detail::initimpl::constructor<sdf_tools::real3, sdf_tools::real3, bool>::execute<pybind11::class_<sdf_tools::sdf::SdfBox, std::shared_p... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x2c372(%rip), %r15 # 0x52ec8
movq %r15, 0x10(%rsp)
incq (%r15)
ca... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::argument_loader<pybind11::detail::value_and_holder&, sdf_tools::real3, sdf_tools::real3, bool>::load_impl_sequence<0ul, 1ul, 2ul, 3ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
movq %rsi, 0x38(%rdi)
addq $0x20, %rdi
movq 0x8(%rax), %rsi
andl $0x2, %edx
shrl %edx
callq 0x22d2c
testb %al, %al
je 0x26ebf
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x2... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
bool pybind11::detail::argument_loader<pybind11::detail::value_and_holder&, sdf_tools::real3, sdf_tools::real3, float, bool>::load_impl_sequence<0ul, 1ul, 2ul, 3ul, 4ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul, 4ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
movq %rsi, 0x38(%rdi)
addq $0x20, %rdi
movq 0x8(%rax), %rsi
andl $0x2, %edx
shrl %edx
callq 0x22d2c
testb %al, %al
je 0x2761a
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x2... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::class_<sdf_tools::sdf::SdfFromMesh, std::shared_ptr<sdf_tools::sdf::SdfFromMesh>>& pybind11::class_<sdf_tools::sdf::SdfFromMesh, std::shared_ptr<sdf_tools::sdf::SdfFromMesh>>::def<void pybind11::detail::initimpl::constructor<std::vector<sdf_tools::int3, std::allocator<sdf_tools::int3>>, std::vector<sdf_tools:... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x29f56(%rip), %r15 # 0x52ec8
movq %r15, 0x10(%rsp)
incq (%r15)
ca... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<void pybind11::detail::initimpl::constructor<std::vector<sdf_tools::int3, std::allocator<sdf_tools::int3>>, std::vector<sdf_tools::real3, std::allocator<sdf_tools::real3>>, bool>::execute<pybind11::class_<sdf_tools::sdf::SdfFromMesh, std::shared_ptr<sdf_tools::sdf::SdfFromMesh>>,... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
// The unique_ptr makes sure nothing is leaked ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %rbx
movq 0x68(%rsp), %rbp
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x18208
movq (%r13), %rax
leaq 0xf0(%rip), %rcx # 0x291c0
movq %rcx, 0x30(%rax)
movq %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::detail::process_attributes<pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg, char [229]>::init(pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::detail::is_new_style_constructor ... | static void init(const Args&... args, function_record *r) {
int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::init(args, r), 0) ... };
ignore_unused(unused);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %r15
movq 0x40(%rsp), %rbx
movq (%rdi), %rax
movq %rax, (%rbx)
movzwl 0x59(%rbx), %eax
movl %eax, %ecx
orl $0x10, %ecx
movw %cx, 0x59(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x70(%rbx)
movq (%rdx), %rcx
movq %rcx, 0x... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/attr.h |
bool pybind11::detail::argument_loader<pybind11::detail::value_and_holder&, std::vector<sdf_tools::int3, std::allocator<sdf_tools::int3>>, std::vector<sdf_tools::real3, std::allocator<sdf_tools::real3>>, bool>::load_impl_sequence<0ul, 1ul, 2ul, 3ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long,... | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
movq %rsi, 0x38(%rdi)
addq $0x20, %rdi
movq 0x8(%rax), %rsi
andl $0x2, %edx
shrl %edx
callq 0x29326
testb %al, %al
je 0x2931b
leaq 0x8(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x2... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::detail::process_attributes<pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg, char [236]>::init(pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::detail::is_new_style_constructor ... | static void init(const Args&... args, function_record *r) {
int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::init(args, r), 0) ... };
ignore_unused(unused);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %r15
movq 0x40(%rsp), %rbx
movq (%rdi), %rax
movq %rax, (%rbx)
movzwl 0x59(%rbx), %eax
movl %eax, %ecx
orl $0x10, %ecx
movw %cx, 0x59(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x70(%rbx)
movq (%rdx), %rcx
movq %rcx, 0x... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/attr.h |
pybind11::class_<sdf_tools::sdf::SdfPlate, std::shared_ptr<sdf_tools::sdf::SdfPlate>>::init_instance(pybind11::detail::instance*, void const*) | static void init_instance(detail::instance *inst, const void *holder_ptr) {
auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
if (!v_h.instance_registered()) {
register_instance(inst, v_h.value_ptr(), v_h.type);
v_h.set_instance_registered();
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x27c91(%rip), %rax # 0x520b8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorl %esi, %esi
callq 0x19ecd
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1c8... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfPlate, std::shared_ptr<sdf_tools::sdf::SdfPlate>>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd20
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x2a541
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x2a544
shrb $0x2, %al
movq 0x18(%rbx), %rcx
testb $0x1, %al
j... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfPlate, std::shared_ptr<sdf_tools::sdf::SdfPlate>>::init_holder(pybind11::detail::instance*, pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::SdfPlate> const*, void const*) | static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
if (holder_ptr) {
init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
... | pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0x2a5ea
movq 0x18(%rbx), %rcx
movq (%rdx), %rax
movq %rax, 0x8(%rcx)
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x2a60a
movq 0x28970(%rip), %rcx # 0x52f50
cmpb $0x0, (%rcx)
je 0x2a606
incl 0x8(%rax)
jmp 0x2a60a
testb $0x1, 0x30(%rdi)
je 0x2a629
movq... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfSphere, std::shared_ptr<sdf_tools::sdf::SdfSphere>>::init_holder(pybind11::detail::instance*, pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::SdfSphere> const*, void const*) | static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
if (holder_ptr) {
init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
... | pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0x2ac74
movq 0x18(%rbx), %rcx
movq (%rdx), %rax
movq %rax, 0x8(%rcx)
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x2ac94
movq 0x282e6(%rip), %rcx # 0x52f50
cmpb $0x0, (%rcx)
je 0x2ac90
incl 0x8(%rax)
jmp 0x2ac94
testb $0x1, 0x30(%rdi)
je 0x2acb3
movq... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::detail::process_attributes<pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg, char [203]>::init(pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::detail::is_new_style_constructor ... | static void init(const Args&... args, function_record *r) {
int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::init(args, r), 0) ... };
ignore_unused(unused);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq 0x38(%rsp), %r12
movq 0x30(%rsp), %r15
movq 0x40(%rsp), %rbx
movq (%rdi), %rax
movq %rax, (%rbx)
movzwl 0x59(%rbx), %eax
movl %eax, %ecx
orl $0x10, %ecx
movw %cx, 0x59(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x70(%rbx)
movq (%rdx), %rcx
movq %rcx, 0x... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/attr.h |
bool pybind11::detail::argument_loader<pybind11::detail::value_and_holder&, sdf_tools::real3, float, bool>::load_impl_sequence<0ul, 1ul, 2ul, 3ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
movq %rsi, 0x20(%rdi)
addq $0x8, %rdi
movq 0x8(%rax), %rsi
andl $0x2, %edx
shrl %edx
callq 0x22d2c
testb %al, %al
je 0x2b0d9
leaq 0x4(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x20... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::class_<sdf_tools::sdf::SdfUnion, std::shared_ptr<sdf_tools::sdf::SdfUnion>>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd20
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x2b2a3
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x2b2a6
shrb $0x2, %al
movq 0x18(%rbx), %rcx
testb $0x1, %al
j... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfUnion, std::shared_ptr<sdf_tools::sdf::SdfUnion>>::init_holder(pybind11::detail::instance*, pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::SdfUnion> const*, void const*) | static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
if (holder_ptr) {
init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
... | pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0x2b34c
movq 0x18(%rbx), %rcx
movq (%rdx), %rax
movq %rax, 0x8(%rcx)
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rcx)
testq %rax, %rax
je 0x2b36c
movq 0x27c0e(%rip), %rcx # 0x52f50
cmpb $0x0, (%rcx)
je 0x2b368
incl 0x8(%rax)
jmp 0x2b36c
testb $0x1, 0x30(%rdi)
je 0x2b38b
movq... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.