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;
eglGetConfigs(_glfw.egl.display, NULL, 0, &nativeCount);
if (!nativeCount)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "EGL: No EGLConfigs returned");
return GLFW_FALSE;
}
nativeConfigs = calloc(nativeCount, sizeof(EGLConfig));
eglGetConfigs(_glfw.egl.display, nativeConfigs, nativeCount, &nativeCount);
usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig));
usableCount = 0;
for (i = 0; i < nativeCount; i++)
{
const EGLConfig n = nativeConfigs[i];
_GLFWfbconfig* u = usableConfigs + usableCount;
// Only consider RGB(A) EGLConfigs
if (!(getEGLConfigAttrib(n, EGL_COLOR_BUFFER_TYPE) & EGL_RGB_BUFFER))
continue;
// Only consider window EGLConfigs
if (!(getEGLConfigAttrib(n, EGL_SURFACE_TYPE) & EGL_WINDOW_BIT))
continue;
#if defined(_GLFW_X11)
// Only consider EGLConfigs with associated Visuals
if (!getEGLConfigAttrib(n, EGL_NATIVE_VISUAL_ID))
continue;
#endif // _GLFW_X11
if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
if (ctxconfig->major == 1)
{
if (!(getEGLConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES_BIT))
continue;
}
else
{
if (!(getEGLConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_ES2_BIT))
continue;
}
}
else if (ctxconfig->client == GLFW_OPENGL_API)
{
if (!(getEGLConfigAttrib(n, EGL_RENDERABLE_TYPE) & EGL_OPENGL_BIT))
continue;
}
u->redBits = getEGLConfigAttrib(n, EGL_RED_SIZE);
u->greenBits = getEGLConfigAttrib(n, EGL_GREEN_SIZE);
u->blueBits = getEGLConfigAttrib(n, EGL_BLUE_SIZE);
u->alphaBits = getEGLConfigAttrib(n, EGL_ALPHA_SIZE);
u->depthBits = getEGLConfigAttrib(n, EGL_DEPTH_SIZE);
u->stencilBits = getEGLConfigAttrib(n, EGL_STENCIL_SIZE);
u->samples = getEGLConfigAttrib(n, EGL_SAMPLES);
u->doublebuffer = GLFW_TRUE;
u->handle = (uintptr_t) n;
usableCount++;
}
closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount);
if (closest)
*result = (EGLConfig) closest->handle;
free(nativeConfigs);
free(usableConfigs);
return closest != NULL;
}
|
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 0x1fef3
movq $0x0, 0x8(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x18(%rsp)
movl $0x8, %esi
movq %rbx, %rdi
callq 0x107f0
movq %rax, %r12
movq 0xd10(%rbp), %rdi
leaq 0x4(%rsp), %r14
movq %rax, %rsi
movl %ebx, %edx
movq %r14, %rcx
callq *0xd40(%rbp)
movslq (%r14), %rbx
movl $0x48, %esi
movq %rbx, %rdi
callq 0x107f0
movq %rax, 0x10(%rsp)
testq %rbx, %rbx
jle 0x1feb2
xorl %r15d, %r15d
movq %rsp, %rbx
movq $0x0, 0x8(%rsp)
movq %r13, 0x30(%rsp)
movq %r12, 0x28(%rsp)
movq (%r12,%r15,8), %r14
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x303f, %edx # imm = 0x303F
movq %rbx, %rcx
callq *0xd38(%rbp)
testl $0x308e, (%rsp) # imm = 0x308E
je 0x1fe7b
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3033, %edx # imm = 0x3033
movq %rbx, %rcx
callq *0xd38(%rbp)
testb $0x4, (%rsp)
je 0x1fe7b
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x302e, %edx # imm = 0x302E
movq %rbx, %rcx
callq *0xd38(%rbp)
cmpl $0x0, (%rsp)
je 0x1fe7b
movl (%r13), %eax
cmpl $0x30001, %eax # imm = 0x30001
je 0x1fd4d
cmpl $0x30002, %eax # imm = 0x30002
jne 0x1fd6f
cmpl $0x1, 0x8(%r13)
jne 0x1fe8e
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3040, %edx # imm = 0x3040
movq %rbx, %rcx
callq *0xd38(%rbp)
testb $0x1, (%rsp)
jne 0x1fd6f
jmp 0x1fe7b
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3040, %edx # imm = 0x3040
movq %rbx, %rcx
callq *0xd38(%rbp)
testb $0x8, (%rsp)
je 0x1fe7b
movq 0x8(%rsp), %r12
movslq %r12d, %r12
leaq (%r12,%r12,8), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %r13
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3024, %edx # imm = 0x3024
movq %rbx, %rcx
callq *0xd38(%rbp)
movl (%rsp), %eax
movl %eax, (%r13)
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3023, %edx # imm = 0x3023
movq %rbx, %rcx
callq *0xd38(%rbp)
movl (%rsp), %eax
movl %eax, 0x4(%r13)
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3022, %edx # imm = 0x3022
movq %rbx, %rcx
callq *0xd38(%rbp)
movl (%rsp), %eax
movl %eax, 0x8(%r13)
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3021, %edx # imm = 0x3021
movq %rbx, %rcx
callq *0xd38(%rbp)
movl (%rsp), %eax
movl %eax, 0xc(%r13)
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3025, %edx # imm = 0x3025
movq %rbx, %rcx
callq *0xd38(%rbp)
movl (%rsp), %eax
movl %eax, 0x10(%r13)
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3026, %edx # imm = 0x3026
movq %rbx, %rcx
callq *0xd38(%rbp)
movl (%rsp), %eax
movl %eax, 0x14(%r13)
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3031, %edx # imm = 0x3031
movq %rbx, %rcx
callq *0xd38(%rbp)
movl (%rsp), %eax
movl %eax, 0x30(%r13)
movl $0x1, 0x38(%r13)
movq %r14, 0x40(%r13)
movq 0x30(%rsp), %r13
incl %r12d
movq %r12, 0x8(%rsp)
movq 0x28(%rsp), %r12
incq %r15
movslq 0x4(%rsp), %rax
cmpq %rax, %r15
jl 0x1fca0
jmp 0x1feb2
movq 0xd10(%rbp), %rdi
movq %r14, %rsi
movl $0x3040, %edx # imm = 0x3040
movq %rbx, %rcx
callq *0xd38(%rbp)
testb $0x4, (%rsp)
jne 0x1fd6f
jmp 0x1fe7b
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x140cb
testq %rax, %rax
je 0x1fed7
movq 0x40(%rax), %rcx
movq 0x18(%rsp), %rdx
movq %rcx, (%rdx)
xorl %ebx, %ebx
testq %rax, %rax
setne %bl
movq %r12, %rdi
callq 0x10430
movq 0x10(%rsp), %rdi
callq 0x10430
jmp 0x1ff08
leaq 0x82b1(%rip), %rsi # 0x281ab
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x14954
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to make context current: %s",
getEGLErrorString(eglGetError()));
return;
}
}
else
{
if (!eglMakeCurrent(_glfw.egl.display,
EGL_NO_SURFACE,
EGL_NO_SURFACE,
EGL_NO_CONTEXT))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to clear current context: %s",
getEGLErrorString(eglGetError()));
return;
}
}
_glfwPlatformSetCurrentContext(window);
}
|
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 0x8261(%rip), %rsi # 0x281c7
jmp 0x1ff98
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
testl %eax, %eax
je 0x1ff83
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e419
callq *0xd50(%r14)
movl %eax, %edi
callq 0x1f78e
leaq 0x8257(%rip), %rsi # 0x281ef
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14954
|
/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)
return proc;
}
return eglGetProcAddress(procname);
}
|
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)
{
_glfw_dlclose(window->context.egl.client);
window->context.egl.client = NULL;
}
}
if (window->context.egl.surface)
{
eglDestroySurface(_glfw.egl.display, window->context.egl.surface);
window->context.egl.surface = EGL_NO_SURFACE;
}
if (window->context.egl.handle)
{
eglDestroyContext(_glfw.egl.display, window->context.egl.handle);
window->context.egl.handle = EGL_NO_CONTEXT;
}
}
|
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(%rbx)
movq 0x280(%rbx), %rsi
testq %rsi, %rsi
je 0x200bf
leaq 0xead1(%rip), %rax # 0x2eb78
movq 0xd10(%rax), %rdi
callq *0xd80(%rax)
movq $0x0, 0x280(%rbx)
popq %rbx
retq
|
/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 = VisualScreenMask | VisualIDMask;
if (!chooseEGLConfig(ctxconfig, fbconfig, &native))
{
_glfwInputError(GLFW_FORMAT_UNAVAILABLE,
"EGL: Failed to find a suitable EGLConfig");
return GLFW_FALSE;
}
eglGetConfigAttrib(_glfw.egl.display, native,
EGL_NATIVE_VISUAL_ID, &visualID);
desired.screen = _glfw.x11.screen;
desired.visualid = visualID;
result = XGetVisualInfo(_glfw.x11.display, vimask, &desired, &count);
if (!result)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to retrieve Visual for EGLConfig");
return GLFW_FALSE;
}
*visual = result->visual;
*depth = result->depth;
XFree(result);
return GLFW_TRUE;
}
|
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), %r15
movl $0x302e, %edx # imm = 0x302E
movq %r15, %rcx
callq *0xd38(%r12)
movl 0x138(%r12), %eax
leaq 0x10(%rsp), %rdx
movl %eax, 0x10(%rdx)
movslq (%r15), %rax
movq %rax, 0x8(%rdx)
movq 0x130(%r12), %rdi
movq %rsp, %rcx
movl $0x3, %esi
callq 0x10870
testq %rax, %rax
je 0x2016c
movq (%rax), %rcx
movq %rcx, (%r14)
movl 0x14(%rax), %ecx
movl %ecx, (%rbx)
movq %rax, %rdi
callq 0x10080
movl $0x1, %ebp
jmp 0x20181
leaq 0x7b8f(%rip), %rsi # 0x27cf4
movl $0x10009, %edi # imm = 0x10009
jmp 0x2017a
leaq 0x7c8a(%rip), %rsi # 0x27dfd
xorl %ebp, %ebp
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x14954
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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 window->context.egl.handle;
}
|
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 0x14954
movq %rbx, %rax
popq %rbx
retq
|
/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 window->context.egl.surface;
}
|
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 0x14954
movq %rbx, %rax
popq %rbx
retq
|
/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.
*/
if(curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
fprintf(stderr, "curl_global_init() failed\n");
return TEST_ERR_MAJOR_BAD;
}
easy = curl_easy_init();
/* First set the URL that is about to receive our POST. */
test_setopt(easy, CURLOPT_URL, URL);
/* get verbose debug output please */
test_setopt(easy, CURLOPT_VERBOSE, 1L);
/* include headers in the output */
test_setopt(easy, CURLOPT_HEADER, 1L);
/* Prepare the callback structure. */
pooh.readptr = data;
pooh.sizeleft = (curl_off_t) strlen(data);
pooh.freecount = 0;
/* Build the mime tree. */
mime = curl_mime_init(easy);
part = curl_mime_addpart(mime);
curl_mime_data(part, "hello", CURL_ZERO_TERMINATED);
curl_mime_name(part, "greeting");
curl_mime_type(part, "application/X-Greeting");
curl_mime_encoder(part, "base64");
hdrs = curl_slist_append(hdrs, "X-Test-Number: 654");
curl_mime_headers(part, hdrs, TRUE);
part = curl_mime_addpart(mime);
curl_mime_filedata(part, "log/file654.txt");
part = curl_mime_addpart(mime);
curl_mime_data_cb(part, (curl_off_t) -1, read_callback, NULL, free_callback,
&pooh);
/* Bind mime data to its easy handle. */
test_setopt(easy, CURLOPT_MIMEPOST, mime);
/* Duplicate the handle. */
easy2 = curl_easy_duphandle(easy);
if(!easy2) {
fprintf(stderr, "curl_easy_duphandle() failed\n");
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
/* Now free the mime structure: it should unbind it from the first
easy handle. */
curl_mime_free(mime);
mime = NULL; /* Already cleaned up. */
/* Perform on the first handle: should not send any data. */
result = curl_easy_perform(easy);
if(result) {
fprintf(stderr, "curl_easy_perform(original) failed\n");
res = (int) result;
goto test_cleanup;
}
/* Perform on the second handle: if the bound mime structure has not been
duplicated properly, it should cause a valgrind error. */
result = curl_easy_perform(easy2);
if(result) {
fprintf(stderr, "curl_easy_perform(duplicated) failed\n");
res = (int) result;
goto test_cleanup;
}
/* Free the duplicated handle: it should call free_callback again.
If the mime copy was bad or not automatically released, valgrind
will signal it. */
curl_easy_cleanup(easy2);
easy2 = NULL; /* Already cleaned up. */
if(pooh.freecount != 2) {
fprintf(stderr, "free_callback() called %d times instead of 2\n",
pooh.freecount);
res = TEST_ERR_FAILURE;
goto test_cleanup;
}
test_cleanup:
curl_easy_cleanup(easy);
curl_easy_cleanup(easy2);
curl_mime_free(mime);
curl_global_cleanup();
return res;
}
|
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 # 0x2004
movb $0x0, %al
callq 0x1140
movl $0x7e, -0x4(%rbp)
jmp 0x15ae
callq 0x1060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2712, %esi # imm = 0x2712
movb $0x0, %al
callq 0x1150
movl %eax, -0x40(%rbp)
cmpl $0x0, %eax
je 0x1340
jmp 0x1588
movq -0x18(%rbp), %rdi
movl $0x29, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x1150
movl %eax, -0x40(%rbp)
cmpl $0x0, %eax
je 0x1362
jmp 0x1588
movq -0x18(%rbp), %rdi
movl $0x2a, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x1150
movl %eax, -0x40(%rbp)
cmpl $0x0, %eax
je 0x1384
jmp 0x1588
leaq 0x2d65(%rip), %rax # 0x40f0
movq %rax, -0x58(%rbp)
leaq 0x2d5a(%rip), %rdi # 0x40f0
callq 0x10a0
movq %rax, -0x50(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1130
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1050
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0xc54(%rip), %rsi # 0x201f
movq $-0x1, %rdx
callq 0x1090
movq -0x30(%rbp), %rdi
leaq 0xc43(%rip), %rsi # 0x2025
callq 0x1100
movq -0x30(%rbp), %rdi
leaq 0xc3c(%rip), %rsi # 0x202e
callq 0x1190
movq -0x30(%rbp), %rdi
leaq 0xc43(%rip), %rsi # 0x2045
callq 0x1160
movq -0x38(%rbp), %rdi
leaq 0xc3a(%rip), %rsi # 0x204c
callq 0x1080
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x1, %edx
callq 0x10b0
movq -0x28(%rbp), %rdi
callq 0x1050
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0xc1a(%rip), %rsi # 0x205f
callq 0x1120
movq -0x28(%rbp), %rdi
callq 0x1050
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq $-0x1, %rsi
leaq 0x157(%rip), %rdx # 0x15c0
xorl %eax, %eax
movl %eax, %ecx
leaq 0x20c(%rip), %r8 # 0x1680
leaq -0x58(%rbp), %r9
callq 0x11a0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x281d, %esi # imm = 0x281D
movb $0x0, %al
callq 0x1150
movl %eax, -0x40(%rbp)
cmpl $0x0, %eax
je 0x149e
jmp 0x1588
movq -0x18(%rbp), %rdi
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14d6
movq 0x2b27(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xbac(%rip), %rsi # 0x206f
movb $0x0, %al
callq 0x1140
movl $0x77, -0x40(%rbp)
jmp 0x1588
movq -0x28(%rbp), %rdi
callq 0x10d0
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1040
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x1519
movq 0x2ae0(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xb83(%rip), %rsi # 0x208d
movb $0x0, %al
callq 0x1140
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x1588
movq -0x20(%rbp), %rdi
callq 0x1040
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x154b
movq 0x2aae(%rip), %rax # 0x3fe0
movq (%rax), %rdi
leaq 0xb75(%rip), %rsi # 0x20b1
movb $0x0, %al
callq 0x1140
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x1588
movq -0x20(%rbp), %rdi
callq 0x1110
movq $0x0, -0x20(%rbp)
cmpl $0x2, -0x48(%rbp)
je 0x1586
movq 0x2a77(%rip), %rax # 0x3fe0
movq (%rax), %rdi
movl -0x48(%rbp), %edx
leaq 0xb61(%rip), %rsi # 0x20d7
movb $0x0, %al
callq 0x1140
movl $0x77, -0x40(%rbp)
jmp 0x1588
jmp 0x1588
movq -0x18(%rbp), %rdi
callq 0x1110
movq -0x20(%rbp), %rdi
callq 0x1110
movq -0x28(%rbp), %rdi
callq 0x10d0
callq 0x1180
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/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 by the C library in order to test for undesired side
* effects that could cause in libcurl.
*/
#ifdef HAVE_SETLOCALE
setlocale(LC_ALL, "");
#endif
if(argc< 2) {
fprintf(stderr, "Pass URL as argument please\n");
return 1;
}
test_argc = argc;
test_argv = argv;
if(argc>2)
libtest_arg2 = argv[2];
if(argc>3)
libtest_arg3 = argv[3];
URL = argv[1]; /* provide this to the rest */
fprintf(stderr, "URL: %s\n", URL);
result = test(URL);
#ifdef USE_NSS
if(PR_Initialized())
/* prevent valgrind from reporting possibly lost memory (fd cache, ...) */
PR_Cleanup();
#endif
return result;
}
|
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 $0x0, %al
callq 0x1140
movl $0x1, -0x4(%rbp)
jmp 0x18c8
movl -0x8(%rbp), %eax
movl %eax, 0x2b43(%rip) # 0x439c
movq -0x10(%rbp), %rax
movq %rax, 0x2b3c(%rip) # 0x43a0
cmpl $0x2, -0x8(%rbp)
jle 0x1879
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28b7(%rip) # 0x4130
cmpl $0x3, -0x8(%rbp)
jle 0x188e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28aa(%rip) # 0x4138
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x273f(%rip), %rax # 0x3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x879(%rip), %rsi # 0x2128
movb $0x0, %al
callq 0x1140
movq -0x18(%rbp), %rdi
callq 0x12b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
|
/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
popq %rax
retq
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x97c0
movb $0x0, (%rbx,%r12)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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, (%rbx)
xorl %r14d, %r14d
leaq 0x40aca(%rip), %rdi # 0x54be8
callq 0x171be
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
/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_id_alloc32(&sock_ids, &s->s_id, s)) != 0) {
nni_mtx_unlock(&sock_lk);
sock_destroy(s);
return (rv);
} else {
nni_list_append(&sock_list, s);
s->s_sock_ops.sock_open(s->s_data);
*sockp = s;
}
nni_mtx_unlock(&sock_lk);
#ifdef NNG_ENABLE_STATS
// Set up basic stat values. The socket id wasn't
// known at stat creation time, so we set it now.
nni_stat_set_id(&s->st_id, (int) s->s_id);
nni_stat_set_id(&s->st_root, (int) s->s_id);
// Add our stats chain.
nni_stat_register(&s->st_root);
#endif
return (0);
}
|
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 %rax, %rbx
addq $0x558, %rax # imm = 0x558
movq %rax, 0xb8(%rbx)
movaps 0x25b15(%rip), %xmm0 # 0x39d10
movups %xmm0, 0x1a8(%rbx)
andq $0x0, 0x1b8(%rbx)
andl $0x0, 0xa8(%rbx)
andl $0x0, 0xb0(%rbx)
movups 0x8(%r15), %xmm0
movups %xmm0, 0xd8(%rbx)
movups 0x18(%r15), %xmm0
movups %xmm0, 0xe8(%rbx)
movl 0x28(%r15), %eax
movl %eax, 0xac(%rbx)
leaq 0x128(%rbx), %rdi
movq 0x30(%r15), %rsi
pushq $0xa
popq %rcx
rep movsq (%rsi), %es:(%rdi)
movq 0x38(%r15), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x118(%rbx)
movups %xmm1, 0x108(%rbx)
movups %xmm0, 0xf8(%rbx)
andw $0x0, 0x220(%rbx)
movq 0x40(%r15), %rax
testq %rax, %rax
je 0x142a0
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x198(%rbx)
movups %xmm1, 0x188(%rbx)
movups %xmm0, 0x178(%rbx)
cmpq $0x0, 0x140(%rbx)
jne 0x142cb
leaq 0x24f9f(%rip), %rdi # 0x39250
leaq 0x25a68(%rip), %rsi # 0x39d20
leaq 0x25bfe(%rip), %rcx # 0x39ebd
movl $0x212, %edx # imm = 0x212
xorl %eax, %eax
callq 0x131a7
cmpq $0x0, 0x148(%rbx)
jne 0x142f6
leaq 0x24f74(%rip), %rdi # 0x39250
leaq 0x25a3d(%rip), %rsi # 0x39d20
leaq 0x25bf3(%rip), %rcx # 0x39edd
movl $0x213, %edx # imm = 0x213
xorl %eax, %eax
callq 0x131a7
leaq 0x208(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %esi, %esi
callq 0x111e4
leaq 0x1f0(%rbx), %rdi
movl $0x98, %esi
callq 0x111e4
leaq 0x1c0(%rbx), %rdi
movl $0x80, %esi
callq 0x111e4
leaq 0x1d8(%rbx), %rdi
pushq $0x70
popq %rsi
callq 0x111e4
leaq 0x10(%rbx), %r15
movq %r15, %rdi
callq 0x171a0
leaq 0x228(%rbx), %rdi
callq 0x171a0
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x171c8
leaq 0x70(%rbx), %rdi
leaq 0x4087e(%rip), %rsi # 0x54be8
callq 0x171c8
leaq 0x298(%rbx), %r15
leaq 0x3d493(%rip), %rsi # 0x51810
movq %r15, %rdi
callq 0x16163
leaq 0x2d8(%rbx), %r12
leaq 0x3d49d(%rip), %rdx # 0x51830
movq %rbx, %rdi
movq %r12, %rsi
callq 0x15d23
leaq 0x318(%rbx), %r13
leaq 0x3d4a4(%rip), %rdx # 0x51850
movq %rbx, %rdi
movq %r13, %rsi
callq 0x15d23
leaq 0x358(%rbx), %rsi
leaq 0x3d4ab(%rip), %rdx # 0x51870
movq %rbx, %rdi
callq 0x15d23
leaq 0x398(%rbx), %rsi
leaq 0x3d4b5(%rip), %rdx # 0x51890
movq %rbx, %rdi
callq 0x15d23
leaq 0x3d8(%rbx), %rsi
leaq 0x3d4bf(%rip), %rdx # 0x518b0
movq %rbx, %rdi
callq 0x15d23
leaq 0x518(%rbx), %rsi
leaq 0x3d4c9(%rip), %rdx # 0x518d0
movq %rbx, %rdi
callq 0x15d23
leaq 0x4d8(%rbx), %rsi
leaq 0x3d4d3(%rip), %rdx # 0x518f0
movq %rbx, %rdi
callq 0x15d23
leaq 0x498(%rbx), %rsi
leaq 0x3d4dd(%rip), %rdx # 0x51910
movq %rbx, %rdi
callq 0x15d23
leaq 0x458(%rbx), %rsi
leaq 0x3d4e7(%rip), %rdx # 0x51930
movq %rbx, %rdi
callq 0x15d23
leaq 0x418(%rbx), %rsi
leaq 0x3d4f1(%rip), %rdx # 0x51950
movq %rbx, %rdi
callq 0x15d23
movl 0xa8(%rbx), %esi
movq %r12, %rdi
callq 0x161a9
movq 0xe0(%rbx), %rsi
movq %r13, %rdi
callq 0x161bc
leaq 0xc8(%rbx), %rdi
xorl %esi, %esi
callq 0x1ee44
testl %eax, %eax
jne 0x144a9
leaq 0xd0(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1ee44
testl %eax, %eax
je 0x144d0
movl %eax, %r13d
movq %rbx, %rdi
callq 0x14628
jmp 0x144be
pushq $0x9
jmp 0x144bc
pushq $0x2
popq %r13
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a8(%rbx), %r13
leaq 0x1ac(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x1b8(%rbx), %rax
movq %rax, -0x40(%rbp)
movq %rbx, %rax
addq $0xa8, %rax
movq %rax, -0x48(%rbp)
movq 0xb8(%rbx), %rdi
movq %rbx, %rsi
callq *0x130(%rbx)
leaq 0x25931(%rip), %rsi # 0x39e42
pushq $0x4
popq %rcx
pushq $0x4
popq %r8
movq %rbx, %rdi
movq %r13, %rdx
movq %rcx, %r13
callq 0x14f34
leaq 0x25908(%rip), %rsi # 0x39e35
movq %rbx, %rdi
movq -0x38(%rbp), %rdx
movq %r13, %rcx
pushq $0x4
popq %r8
callq 0x14f34
leaq 0x259b7(%rip), %rsi # 0x39efe
pushq $0x8
popq %rcx
pushq $0x3
popq %r8
movq %rbx, %rdi
movq -0x40(%rbp), %rdx
callq 0x14f34
leaq -0x29(%rbp), %r13
movb $0x1, (%r13)
leaq 0x259a2(%rip), %rsi # 0x39f0c
pushq $0x1
popq %rcx
pushq $0x1
popq %r8
movq %rbx, %rdi
movq %r13, %rdx
callq 0x14f34
movb $0x0, (%r13)
leaq 0x25990(%rip), %rsi # 0x39f18
movq %rbx, %rdi
movq %r13, %rdx
pushq $0x1
popq %rcx
pushq $0x1
popq %r8
callq 0x14f34
leaq 0x40647(%rip), %rdi # 0x54be8
callq 0x171b4
leaq 0x3efbb(%rip), %rdi # 0x53568
movq -0x48(%rbp), %rsi
movq %rbx, %rdx
callq 0x10edd
testl %eax, %eax
je 0x145d1
movl %eax, %r13d
leaq 0x40621(%rip), %rdi # 0x54be8
callq 0x171be
jmp 0x144ac
leaq 0x3efc8(%rip), %rdi # 0x535a0
movq %rbx, %rsi
callq 0x11222
movq 0xb8(%rbx), %rdi
callq *0x140(%rbx)
movq %rbx, (%r14)
leaq 0x405f1(%rip), %rdi # 0x54be8
callq 0x171be
movl 0xa8(%rbx), %esi
movq %r12, %rdi
callq 0x161a9
movl 0xa8(%rbx), %esi
movq %r15, %rdi
callq 0x161a9
movq %r15, %rdi
callq 0x16070
xorl %r13d, %r13d
jmp 0x144be
|
/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_closing = true;
while ((l = nni_list_first(&sock->s_listeners)) != NULL) {
nni_listener_hold(l);
nni_mtx_unlock(&sock->s_mx);
nni_listener_close(l);
nni_mtx_lock(&sock->s_mx);
}
while ((d = nni_list_first(&sock->s_dialers)) != NULL) {
nni_dialer_hold(d);
nni_mtx_unlock(&sock->s_mx);
nni_dialer_close(d);
nni_mtx_lock(&sock->s_mx);
}
// For each pipe, arrange for it to teardown hard. We would
// expect there not to be any here.
NNI_LIST_FOREACH (&sock->s_pipes, pipe) {
nni_pipe_close(pipe);
}
nni_mtx_unlock(&sock->s_mx);
// Close the upper queues immediately.
nni_msgq_close(sock->s_urq);
nni_msgq_close(sock->s_uwq);
// We now mark any owned contexts as closing.
// XXX: Add context draining support here!
nni_mtx_lock(&sock_lk);
nctx = nni_list_first(&sock->s_ctxs);
while ((ctx = nctx) != NULL) {
nctx = nni_list_next(&sock->s_ctxs, ctx);
ctx->c_closed = true;
if (ctx->c_ref == 0) {
// No open operations. So close it.
nni_id_remove(&ctx_ids, ctx->c_id);
nni_list_remove(&sock->s_ctxs, ctx);
nni_ctx_destroy(ctx);
}
// If still has a reference count, then wait for last
// reference to close before nuking it.
}
// Generally, unless the protocol is blocked trying to perform
// writes (e.g. a slow reader on the other side), it should be
// trying to shut things down. We wait to give it
// a chance to do so gracefully.
while (!nni_list_empty(&sock->s_ctxs)) {
nni_cv_wait(&sock->s_close_cv);
}
nni_mtx_unlock(&sock_lk);
nni_mtx_lock(&sock->s_mx);
// We have to wait for pipes to be removed.
while (!nni_list_empty(&sock->s_pipes)) {
nni_cv_wait(&sock->s_cv);
}
NNI_ASSERT(nni_list_first(&sock->s_pipes) == NULL);
nni_mtx_unlock(&sock->s_mx);
sock->s_sock_ops.sock_close(sock->s_data);
// At this point, there are no threads blocked inside of us
// that are referencing socket state. User code should call
// nng_socket_close to release the last resources.
return (0);
}
|
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
callq 0x111f5
testq %rax, %rax
je 0x1471e
movq %rax, %r15
movq %rax, %rdi
callq 0x11968
movq %r14, %rdi
callq 0x171be
movq %r15, %rdi
callq 0x11a33
movq %r14, %rdi
callq 0x171b4
jmp 0x146ec
leaq 0x1d8(%r12), %rbx
movq %rbx, %rdi
callq 0x111f5
testq %rax, %rax
je 0x14758
movq %rax, %r15
movq %rax, %rdi
callq 0x1020a
movq %r14, %rdi
callq 0x171be
movq %r15, %rdi
callq 0x102d5
movq %r14, %rdi
callq 0x171b4
jmp 0x14726
leaq 0x1f0(%r12), %r15
movq %r15, %rdi
callq 0x111f5
movq %rax, %rbx
testq %rax, %rax
je 0x14785
movq %rbx, %rdi
callq 0x13321
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11361
jmp 0x14768
movq %r14, %rdi
callq 0x171be
movq 0xd0(%r12), %rdi
callq 0x1f2f1
movq 0xc8(%r12), %rdi
callq 0x1f2f1
leaq 0x4043a(%rip), %rdi # 0x54be8
callq 0x171b4
movq %r12, -0x30(%rbp)
addq $0x208, %r12 # imm = 0x208
movq %r12, %rdi
callq 0x111f5
movq %rax, %r13
testq %r13, %r13
je 0x1480d
movq %r13, %rbx
movq %r12, %rdi
movq %r13, %rsi
callq 0x11361
movq %rax, %r13
movb $0x1, 0x58(%rbx)
cmpl $0x0, 0x5c(%rbx)
jne 0x147c9
movl 0x60(%rbx), %esi
leaq 0x3edc5(%rip), %rdi # 0x535b8
callq 0x10a7f
movq %r12, %rdi
movq %rbx, %rsi
callq 0x113aa
movq %rbx, %rdi
callq 0x148ae
jmp 0x147c9
movq -0x30(%rbp), %r13
leaq 0x70(%r13), %rbx
movq %r12, %rdi
callq 0x113df
testl %eax, %eax
jne 0x1482b
movq %rbx, %rdi
callq 0x171dc
jmp 0x14815
leaq 0x403b6(%rip), %rdi # 0x54be8
callq 0x171be
movq %r14, %rdi
callq 0x171b4
leaq 0x38(%r13), %rbx
movq %r15, %rdi
callq 0x113df
testl %eax, %eax
jne 0x14859
movq %rbx, %rdi
callq 0x171dc
jmp 0x14843
movq %r15, %rdi
callq 0x111f5
testq %rax, %rax
je 0x14887
leaq 0x249e3(%rip), %rdi # 0x39250
leaq 0x254ac(%rip), %rsi # 0x39d20
leaq 0x254f7(%rip), %rcx # 0x39d72
movl $0x2b6, %edx # imm = 0x2B6
xorl %eax, %eax
callq 0x131a7
movq %r14, %rdi
callq 0x171be
movq 0xb8(%r13), %rdi
callq *0x148(%r13)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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);
return;
}
s->s_closed = true;
nni_id_remove(&sock_ids, s->s_id);
// We might have been removed from the list already, e.g. by
// nni_sock_closeall. This is idempotent.
nni_list_node_remove(&s->s_node);
// Wait for all other references to drop. Note that we
// have a reference already (from our caller).
while ((s->s_ref > 1) || (!nni_list_empty(&s->s_ctxs))) {
nni_cv_wait(&s->s_close_cv);
}
nni_mtx_unlock(&sock_lk);
// Because we already shut everything down before, we should not
// have any child objects.
nni_mtx_lock(&s->s_mx);
NNI_ASSERT(nni_list_empty(&s->s_dialers));
NNI_ASSERT(nni_list_empty(&s->s_listeners));
NNI_ASSERT(nni_list_empty(&s->s_pipes));
nni_mtx_unlock(&s->s_mx);
sock_destroy(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 0x14156
movb $0x1, 0x221(%rbx)
movl 0xa8(%rbx), %esi
leaq 0x3ec3a(%rip), %rdi # 0x53568
callq 0x10a7f
movq %rbx, %rdi
callq 0x11408
leaq 0x208(%rbx), %r14
leaq 0x70(%rbx), %r15
cmpl $0x1, 0xb0(%rbx)
ja 0x1495b
movq %r14, %rdi
callq 0x113df
testl %eax, %eax
jne 0x14965
movq %r15, %rdi
callq 0x171dc
jmp 0x14946
leaq 0x4027c(%rip), %rdi # 0x54be8
callq 0x171be
leaq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0x171b4
leaq 0x1d8(%rbx), %rdi
callq 0x113df
testl %eax, %eax
jne 0x149ae
leaq 0x248bc(%rip), %rdi # 0x39250
leaq 0x25385(%rip), %rsi # 0x39d20
leaq 0x253f7(%rip), %rcx # 0x39d99
movl $0x2e5, %edx # imm = 0x2E5
xorl %eax, %eax
callq 0x131a7
leaq 0x1c0(%rbx), %rdi
callq 0x113df
testl %eax, %eax
jne 0x149df
leaq 0x2488b(%rip), %rdi # 0x39250
leaq 0x25354(%rip), %rsi # 0x39d20
leaq 0x253e4(%rip), %rcx # 0x39db7
movl $0x2e6, %edx # imm = 0x2E6
xorl %eax, %eax
callq 0x131a7
leaq 0x1f0(%rbx), %rdi
callq 0x113df
testl %eax, %eax
jne 0x14a10
leaq 0x2485a(%rip), %rdi # 0x39250
leaq 0x25323(%rip), %rsi # 0x39d20
leaq 0x253d3(%rip), %rcx # 0x39dd7
movl $0x2e7, %edx # imm = 0x2E7
xorl %eax, %eax
callq 0x131a7
movq %r14, %rdi
callq 0x171be
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14628
|
/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(&sock_lk);
nni_sock_close(s);
}
}
|
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 0x171be
movq %r15, %rdi
callq 0x148d5
jmp 0x14a42
leaq 0x40167(%rip), %rdi # 0x54be8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x171be
|
/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 enough
const nni_ep_option *o = &ep_options[i];
rv = nni_sock_getopt(s, o->eo_name, &val, NULL, o->eo_type);
if (rv == 0) {
rv = nni_listener_setopt(
l, o->eo_name, &val, 0, o->eo_type);
}
if (rv != 0 && rv != NNG_ENOTSUP) {
nni_listener_rele(l);
return (rv);
}
}
nni_mtx_lock(&s->s_mx);
if (s->s_closing) {
nni_mtx_unlock(&s->s_mx);
nni_listener_rele(l);
return (NNG_ECLOSED);
}
nni_list_append(&s->s_listeners, l);
#ifdef NNG_ENABLE_STATS
nni_stat_inc(&s->st_listeners, 1);
#endif
nni_mtx_unlock(&s->s_mx);
return (0);
}
|
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 $0x38, %rbx
je 0x14c27
leaq 0x3cb54(%rip), %rax # 0x51710
movq -0x8(%rbx,%rax), %r12
movl (%rbx,%rax), %r15d
movq %r13, %r14
movq %r13, %rdi
movq %r12, %rsi
leaq -0x40(%rbp), %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x14c8f
movl %eax, %r13d
testl %eax, %eax
jne 0x14bfb
movq -0x30(%rbp), %rdi
movq %r12, %rsi
leaq -0x40(%rbp), %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x11be5
movl %eax, %r13d
testl %r13d, %r13d
je 0x14c13
cmpl $0x9, %r13d
je 0x14c13
movq -0x30(%rbp), %rdi
callq 0x119a8
movl %r13d, -0x34(%rbp)
cmpl $0x9, %r13d
je 0x14c1e
testl %r13d, %r13d
jne 0x14c87
addq $0x10, %rbx
movq %r14, %r13
jmp 0x14baf
leaq 0x10(%r13), %r15
movq %r15, %rdi
callq 0x171b4
cmpb $0x1, 0x220(%r13)
jne 0x14c56
movq %r15, %rdi
callq 0x171be
movq -0x30(%rbp), %rdi
callq 0x119a8
pushq $0x7
popq %rax
jmp 0x14b99
leaq 0x1c0(%r13), %rdi
movq -0x30(%rbp), %rsi
callq 0x11222
addq $0x398, %r13 # imm = 0x398
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0x1616f
movq %r15, %rdi
callq 0x171be
xorl %eax, %eax
jmp 0x14b99
movl -0x34(%rbp), %eax
jmp 0x14b99
|
/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 descriptors
// this way.
rv = nni_getopt(
s->s_sock_ops.sock_options, name, s->s_data, val, szp, t);
if (rv != NNG_ENOTSUP) {
nni_mtx_unlock(&s->s_mx);
return (rv);
}
// Socket generic options.
rv = nni_getopt(sock_options, name, s, val, szp, t);
if (rv != NNG_ENOTSUP) {
nni_mtx_unlock(&s->s_mx);
return (rv);
}
nni_mtx_unlock(&s->s_mx);
return (rv);
}
|
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), %rdx
movq 0x170(%r13), %rdi
movq %r14, %rsi
movq %r12, %rcx
movq -0x38(%rbp), %r8
movl %r15d, -0x2c(%rbp)
movl %r15d, %r9d
callq 0x13023
movl %eax, %r15d
cmpl $0x9, %eax
jne 0x14d18
leaq 0x3ca51(%rip), %rdi # 0x51750
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x13023
movl %eax, %r15d
movq %rbx, %rdi
callq 0x171be
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 0x25079(%rip), %rcx # 0x39df3
movl $0x376, %edx # imm = 0x376
xorl %eax, %eax
callq 0x131a7
movq %r15, %rdi
callq 0x11408
movq %r14, %rdi
callq 0x171be
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x119a8
|
/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
const nni_ep_option *o = &ep_options[i];
rv = nni_sock_getopt(s, o->eo_name, &val, NULL, o->eo_type);
if (rv == 0) {
rv = nni_dialer_setopt(
d, o->eo_name, &val, 0, o->eo_type);
}
if (rv != 0 && rv != NNG_ENOTSUP) {
nni_dialer_rele(d);
return (rv);
}
}
nni_mtx_lock(&s->s_mx);
if (s->s_closing) {
nni_mtx_unlock(&s->s_mx);
nni_dialer_rele(d);
return (NNG_ECLOSED);
}
nni_list_append(&s->s_dialers, d);
#ifdef NNG_ENABLE_STATS
nni_stat_inc(&s->st_dialers, 1);
#endif
nni_mtx_unlock(&s->s_mx);
return (0);
}
|
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 $0x38, %rbx
je 0x14e59
leaq 0x3c922(%rip), %rax # 0x51710
movq -0x8(%rbx,%rax), %r12
movl (%rbx,%rax), %r15d
movq %r13, %r14
movq %r13, %rdi
movq %r12, %rsi
leaq -0x40(%rbp), %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x14c8f
movl %eax, %r13d
testl %eax, %eax
jne 0x14e2d
movq -0x30(%rbp), %rdi
movq %r12, %rsi
leaq -0x40(%rbp), %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x10466
movl %eax, %r13d
testl %r13d, %r13d
je 0x14e45
cmpl $0x9, %r13d
je 0x14e45
movq -0x30(%rbp), %rdi
callq 0x1024a
movl %r13d, -0x34(%rbp)
cmpl $0x9, %r13d
je 0x14e50
testl %r13d, %r13d
jne 0x14eb9
addq $0x10, %rbx
movq %r14, %r13
jmp 0x14de1
leaq 0x10(%r13), %r15
movq %r15, %rdi
callq 0x171b4
cmpb $0x1, 0x220(%r13)
jne 0x14e88
movq %r15, %rdi
callq 0x171be
movq -0x30(%rbp), %rdi
callq 0x1024a
pushq $0x7
popq %rax
jmp 0x14dcb
leaq 0x1d8(%r13), %rdi
movq -0x30(%rbp), %rsi
callq 0x11222
addq $0x358, %r13 # imm = 0x358
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0x1616f
movq %r15, %rdi
callq 0x171be
xorl %eax, %eax
jmp 0x14dcb
movl -0x34(%rbp), %eax
jmp 0x14dcb
|
/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_data = ctx + 1;
ctx->c_closed = false;
ctx->c_ref = 1; // Caller implicitly gets a reference.
ctx->c_sock = sock;
ctx->c_ops = sock->s_ctx_ops;
ctx->c_rcvtimeo = sock->s_rcvtimeo;
ctx->c_sndtimeo = sock->s_sndtimeo;
nni_mtx_lock(&sock_lk);
if (sock->s_closed) {
nni_mtx_unlock(&sock_lk);
nni_free(ctx, ctx->c_size);
return (NNG_ECLOSED);
}
if ((rv = nni_id_alloc32(&ctx_ids, &ctx->c_id, ctx)) != 0) {
nni_mtx_unlock(&sock_lk);
nni_free(ctx, ctx->c_size);
return (rv);
}
sock->s_ctx_ops.ctx_init(ctx->c_data, sock->s_data);
nni_list_append(&sock->s_ctxs, ctx);
nni_mtx_unlock(&sock_lk);
// Paranoia, fixing a possible race in close. Don't let us
// give back a context if the socket is being shutdown (it
// might not have reached the "closed" state yet.)
nni_mtx_lock(&sock->s_mx);
if (sock->s_closing) {
nni_mtx_unlock(&sock->s_mx);
nni_ctx_rele(ctx);
return (NNG_ECLOSED);
}
nni_mtx_unlock(&sock->s_mx);
*ctxp = ctx;
return (0);
}
|
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 $0x70, %rax
movq %rax, 0x48(%rbx)
movb $0x0, 0x58(%rbx)
movl $0x1, 0x5c(%rbx)
movq %r15, 0x10(%rbx)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm0, 0x18(%rbx)
movups %xmm1, 0x28(%rbx)
movups %xmm2, 0x38(%rbx)
movq 0x1a8(%r15), %rax
movq %rax, 0x64(%rbx)
leaq 0x3fa0e(%rip), %rdi # 0x54be8
callq 0x171b4
cmpb $0x1, 0x221(%r15)
jne 0x1521f
leaq 0x3f9f8(%rip), %rdi # 0x54be8
callq 0x171be
movq 0x50(%rbx), %rsi
movq %rbx, %rdi
callq 0x181c7
pushq $0x7
jmp 0x1520b
pushq $0x9
jmp 0x1520b
pushq $0x2
popq %r12
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
addq $0x60, %rsi
leaq 0x3e38b(%rip), %rdi # 0x535b8
movq %rbx, %rdx
callq 0x10edd
testl %eax, %eax
je 0x15256
movl %eax, %r12d
leaq 0x3f9a5(%rip), %rdi # 0x54be8
callq 0x171be
movq 0x50(%rbx), %rsi
movq %rbx, %rdi
callq 0x181c7
jmp 0x1520d
movq 0x48(%rbx), %rdi
movq 0xb8(%r15), %rsi
callq *0x180(%r15)
leaq 0x208(%r15), %rdi
movq %rbx, %rsi
callq 0x11222
leaq 0x3f96a(%rip), %rdi # 0x54be8
callq 0x171be
leaq 0x10(%r15), %r12
movq %r12, %rdi
callq 0x171b4
movb 0x220(%r15), %r15b
movq %r12, %rdi
callq 0x171be
cmpb $0x1, %r15b
jne 0x152b1
movq %rbx, %rdi
callq 0x150da
jmp 0x15201
movq %rbx, (%r14)
xorl %r12d, %r12d
jmp 0x1520d
|
/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_OPT_SENDTIMEO) == 0) {
rv = nni_copyout_ms(ctx->c_sndtimeo, v, szp, t);
} else if (ctx->c_ops.ctx_options != NULL) {
for (o = ctx->c_ops.ctx_options; o->o_name != NULL; o++) {
if (strcmp(opt, o->o_name) != 0) {
continue;
}
if (o->o_get == NULL) {
rv = NNG_EWRITEONLY;
break;
}
rv = o->o_get(ctx->c_data, v, szp, t);
break;
}
}
nni_mtx_unlock(&sock->s_mx);
return (rv);
}
|
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 0x95d0
testl %eax, %eax
je 0x153d8
movq %r15, -0x40(%rbp)
leaq 0x24aab(%rip), %rsi # 0x39e42
movq %r14, %rdi
callq 0x95d0
testl %eax, %eax
je 0x153e0
movq %r13, -0x48(%rbp)
movl %r12d, -0x34(%rbp)
movq 0x40(%rbx), %r12
pushq $0x9
popq %r15
testq %r12, %r12
je 0x153f5
addq $0x8, %r12
movq -0x8(%r12), %rsi
testq %rsi, %rsi
je 0x153f5
movq %r14, %rdi
callq 0x95d0
testl %eax, %eax
je 0x15413
addq $0x18, %r12
jmp 0x153bc
movl 0x68(%rbx), %edi
movq %r15, %rsi
jmp 0x153e7
movl 0x64(%rbx), %edi
movq -0x40(%rbp), %rsi
movq %r13, %rdx
movl %r12d, %ecx
callq 0x12fa5
movl %eax, %r15d
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x171be
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rax
testq %rax, %rax
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %r14
je 0x15436
movq 0x48(%rbx), %rdi
movq -0x48(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq *%rax
movl %eax, %r15d
jmp 0x153f9
pushq $0x19
popq %r15
jmp 0x153f9
|
/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, NNG_OPT_SENDTIMEO) == 0) {
rv = nni_copyin_ms(&ctx->c_sndtimeo, v, sz, t);
} else if (ctx->c_ops.ctx_options != NULL) {
for (o = ctx->c_ops.ctx_options; o->o_name != NULL; o++) {
if (strcmp(opt, o->o_name) != 0) {
continue;
}
if (o->o_set == NULL) {
rv = NNG_EREADONLY;
break;
}
rv = o->o_set(ctx->c_data, v, sz, t);
break;
}
}
nni_mtx_unlock(&sock->s_mx);
return (rv);
}
|
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 0x95d0
testl %eax, %eax
je 0x154d0
movq %r15, -0x40(%rbp)
leaq 0x249b7(%rip), %rsi # 0x39e42
movq %r14, %rdi
callq 0x95d0
testl %eax, %eax
je 0x154dc
movq %rbx, -0x48(%rbp)
movl %r12d, -0x34(%rbp)
movq 0x40(%r13), %r12
pushq $0x9
popq %r15
testq %r12, %r12
je 0x154f5
addq $0x10, %r12
movq -0x30(%rbp), %rbx
movq -0x10(%r12), %rsi
testq %rsi, %rsi
je 0x154f9
movq %r14, %rdi
callq 0x95d0
testl %eax, %eax
je 0x15513
addq $0x18, %r12
jmp 0x154b4
addq $0x68, %r13
movq %r13, %rdi
movq %r15, %rsi
jmp 0x154e7
addq $0x64, %r13
movq %r13, %rdi
movq -0x40(%rbp), %rsi
movq %rbx, %rdx
movl %r12d, %ecx
callq 0x12e60
movl %eax, %r15d
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x171be
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rax
testq %rax, %rax
movq -0x40(%rbp), %rsi
je 0x15532
movq 0x48(%r13), %rdi
movq -0x48(%rbp), %rdx
movl -0x34(%rbp), %ecx
callq *%rax
movl %eax, %r15d
jmp 0x154f9
pushq $0x18
popq %r15
jmp 0x154f9
|
/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, in the range of [0, back_off-1]; this is
// pretty similar to 802 style back-off, except that we have a
// nearly uniform time period instead of discrete slot times.
// This algorithm may lead to slight biases because we don't
// have a statistically perfect distribution with the modulo of
// the random number, but this really doesn't matter.
nni_sleep_aio(back_off ? (nng_duration) (nni_random() % back_off) : 0,
&d->d_tmo_aio);
}
|
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
xorl %edi, %edi
addq $0x2a8, %rbx # imm = 0x2A8
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xf2e3
|
/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
movq %r14, %rdi
callq 0x111f5
movq %rax, %r15
testq %rax, %rax
je 0x1562a
movq %r15, %rdi
callq 0x13321
movq %r14, %rdi
movq %r15, %rsi
callq 0x11361
jmp 0x1560d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x171be
|
/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_pipes, p) {
nni_pipe_close(p);
}
nni_mtx_unlock(&s->s_mx);
// Go back to the end of reap list.
nni_reap(&listener_reap_list, l);
return;
}
nni_list_node_remove(&l->l_node);
nni_mtx_unlock(&s->s_mx);
nni_sock_rele(s);
nni_listener_destroy(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->s_want_evs;
nni_mtx_unlock(&s->s_pipe_cbs_mtx);
if (wantevs) {
nni_mtx_lock(&serialize);
// this pipe never got an event before, so don't start now
if (p->p_last_event == NNG_PIPE_EV_NONE &&
ev != NNG_PIPE_EV_ADD_PRE) {
nni_mtx_unlock(&serialize);
return;
}
if (p->p_last_event >= ev) {
// this pipe event already was notified, or a "later"
// one was, so don't go backwards.
nni_mtx_unlock(&serialize);
return;
}
p->p_last_event = ev;
nng_pipe pid;
pid.id = p->p_id;
if (cb != NULL) {
cb(pid, ev, arg);
}
nni_mtx_unlock(&serialize);
}
}
|
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 0x290(%r15), %r15b
movq %r12, %rdi
callq 0x171be
cmpb $0x1, %r15b
jne 0x15bdc
leaq 0x3f088(%rip), %rdi # 0x54c10
callq 0x171b4
movl 0xf8(%r14), %eax
testl %eax, %eax
sete %cl
cmpl $0x1, %ebx
setne %dl
andb %cl, %dl
cmpl %ebx, %eax
setae %al
orb %dl, %al
jne 0x15bc2
movl %ebx, 0xf8(%r14)
testq %r13, %r13
je 0x15bc2
movl (%r14), %edi
movl %ebx, %esi
movq -0x30(%rbp), %rdx
callq *%r13
leaq 0x3f047(%rip), %rdi # 0x54c10
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x171be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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, 1);
}
#endif
nni_list_node_remove(&p->p_sock_node);
nni_list_node_remove(&p->p_ep_node);
if ((d != NULL) && (d->d_pipe == p)) {
d->d_pipe = NULL;
dialer_timer_start_locked(d); // Kick the timer to redial.
}
nni_cv_wake(&s->s_cv);
nni_mtx_unlock(&s->s_mx);
}
|
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 # imm = 0x5D8
pushq $0x1
popq %rsi
callq 0x1618c
movq 0xc0(%r12), %rdi
testq %rdi, %rdi
je 0x15c5a
addq $0x610, %rdi # imm = 0x610
pushq $0x1
popq %rsi
callq 0x1618c
leaq 0x98(%r12), %rdi
callq 0x11408
leaq 0xa8(%r12), %rdi
callq 0x11408
testq %r15, %r15
je 0x15c92
cmpq %r12, 0x88(%r15)
jne 0x15c92
andq $0x0, 0x88(%r15)
movq %r15, %rdi
callq 0x15569
addq $0x38, %r14
movq %r14, %rdi
callq 0x17206
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x171be
|
/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, p) {
nni_pipe_close(p);
}
nni_mtx_unlock(&s->s_mx);
// Go back to the end of reap list.
nni_dialer_reap(d);
return;
}
nni_mtx_unlock(&s->s_mx);
nni_sock_rele(s);
nni_dialer_destroy(d);
}
|
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 0x171be
movq %r12, %rdi
callq 0x14156
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xfcb9
movq %r15, %rdi
callq 0x111f5
movq %rax, %r12
testq %rax, %rax
je 0x15f64
movq %r12, %rdi
callq 0x13321
movq %r15, %rdi
movq %r12, %rsi
callq 0x11361
jmp 0x15f47
movq %r14, %rdi
callq 0x171be
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1563c
|
/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_pipes, p) {
nni_pipe_close(p);
}
nni_mtx_unlock(&s->s_mx);
// Go back to the end of reap list.
nni_reap(&listener_reap_list, l);
return;
}
nni_list_node_remove(&l->l_node);
nni_mtx_unlock(&s->s_mx);
nni_sock_rele(s);
nni_listener_destroy(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
callq 0x11408
movq %r14, %rdi
callq 0x171be
movq %r12, %rdi
callq 0x14156
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11435
movq %r15, %rdi
callq 0x111f5
movq %rax, %r12
testq %rax, %rax
je 0x1600e
movq %r12, %rdi
callq 0x13321
movq %r15, %rdi
movq %r12, %rsi
callq 0x11361
jmp 0x15ff1
movq %r14, %rdi
callq 0x171be
leaq 0x3d5fb(%rip), %rdi # 0x53618
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x13a24
nopl (%rax)
|
/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.ll_head.ln_next == NULL) {
NNI_LIST_INIT(&child->si_children, nni_stat_item, si_node);
}
nni_list_append(&parent->si_children, child);
#else
NNI_ARG_UNUSED(parent);
NNI_ARG_UNUSED(child);
#endif
}
|
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 0x11222
|
/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_lock);
return;
}
if (!info->si_alloc) {
// no allocation, just set it.
item->si_u.sv_string = (char *) s;
nni_mtx_unlock(&stats_val_lock);
return;
}
item->si_u.sv_string = nni_strdup(s);
nni_mtx_unlock(&stats_val_lock);
nni_strfree(old);
#else
NNI_ARG_UNUSED(item);
NNI_ARG_UNUSED(s);
#endif
}
|
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, %rsi
callq 0x95d0
testl %eax, %eax
je 0x1620f
testb $0x2, 0x18(%r12)
jne 0x16223
movq %r15, 0x38(%r14)
leaq 0x3ea52(%rip), %rdi # 0x54c68
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x171be
movq %r15, %rdi
callq 0x169d4
movq %rax, 0x38(%r14)
leaq 0x3ea32(%rip), %rdi # 0x54c68
callq 0x171be
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x16a0d
|
/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_UNUSED(st);
#endif
}
|
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 0x162b0
movq 0x48(%rbx), %rdi
callq 0x16a0d
pushq $0x50
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x181c7
|
/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;
NNI_LIST_FOREACH (&item->si_children, child) {
nni_stat *cs;
int rv;
if ((rv = stat_make_tree(child, &cs)) != 0) {
nng_stats_free(stat);
return (rv);
}
nni_list_append(&stat->s_children, cs);
cs->s_parent = stat;
}
*sp = stat;
return (0);
}
|
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
movq 0x28(%r14), %rax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
andq $0x0, 0x28(%r15)
addq $0x10, %r14
movq %r14, %rdi
callq 0x111f5
movq %rax, %rbx
testq %rax, %rax
je 0x163ee
movq %rbx, %rdi
leaq -0x38(%rbp), %rsi
callq 0x16357
testl %eax, %eax
jne 0x163fa
movq -0x38(%rbp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x11222
movq %r15, 0x28(%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11361
jmp 0x163b0
pushq $0x2
popq %r13
jmp 0x16405
movq -0x30(%rbp), %rax
movq %r15, (%rax)
xorl %r13d, %r13d
jmp 0x16405
movl %eax, %r13d
movq %r15, %rdi
callq 0x16268
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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_multicast_member(udp, (struct sockaddr *) &ss, join);
break;
#ifdef NNG_ENABLE_IPV6
case AF_INET6:
rv = ip6_multicast_member(udp, (struct sockaddr *) &ss, join);
break;
#endif
default:
rv = NNG_EADDRINVAL;
}
return (rv);
}
|
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), %rdx
movl $0x80, (%rdx)
movl 0x38(%r15), %edi
leaq -0xb0(%rbp), %rsi
callq 0x94d0
xorl %ebx, %ebx
movl $0x0, %edx
testl %eax, %eax
js 0x19a19
cmpw $0x2, -0xb0(%rbp)
jne 0x19aae
movl -0xac(%rbp), %edx
leaq -0x30(%rbp), %rcx
movl %edx, 0x4(%rcx)
movl -0x12c(%rbp), %eax
movl %eax, (%rcx)
movl 0x38(%r15), %edi
movzbl %r14b, %eax
pushq $0x24
popq %rdx
subl %eax, %edx
pushq $0x8
popq %r8
xorl %esi, %esi
jmp 0x19a95
leaq -0x1c(%rbp), %rdx
movl $0x80, (%rdx)
movl 0x38(%r15), %edi
leaq -0xb0(%rbp), %rsi
callq 0x94d0
xorl %ebx, %ebx
movl $0x0, %edx
testl %eax, %eax
js 0x19a72
cmpw $0xa, -0xb0(%rbp)
jne 0x19aae
movl -0x98(%rbp), %edx
leaq -0x30(%rbp), %rcx
movl %edx, 0x10(%rcx)
movups -0x128(%rbp), %xmm0
movaps %xmm0, (%rcx)
movl 0x38(%r15), %edi
movzbl %r14b, %edx
xorl $0x15, %edx
pushq $0x29
popq %rsi
pushq $0x14
popq %r8
callq 0x92c0
testl %eax, %eax
je 0x19ab1
callq 0x9590
movl (%rax), %edi
callq 0x184a9
movl %eax, %ebx
jmp 0x19ab1
pushq $0xf
popq %rbx
movl %ebx, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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
movl %ebx, %esi
callq 0xf033
jmp 0x19ad9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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_reset(&pfd->closing);
pfd->pq = pq;
pfd->fd = fd;
pfd->cb = cb;
pfd->arg = arg;
pfd->added = false;
NNI_LIST_NODE_INIT(&pfd->node);
}
|
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
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movl %r12d, %edi
xorl %eax, %eax
callq 0x97d0
pushq $0x4
popq %rsi
movl %r12d, %edi
movl $0x800, %edx # imm = 0x800
xorl %eax, %eax
callq 0x97d0
leaq 0x30(%rbx), %rdi
callq 0x18212
leaq 0x35(%rbx), %rdi
callq 0x181e0
leaq 0x36(%rbx), %rdi
callq 0x181e0
movq %r13, 0x10(%rbx)
movl %r12d, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movb $0x0, 0x34(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12f8f
|
/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
// be canceled too.
if (nni_list_first(&p->sendq) == aio) {
nni_aio_abort(&p->txaio, rv);
nni_mtx_unlock(&p->mtx);
return;
}
nni_aio_list_remove(aio);
nni_mtx_unlock(&p->mtx);
nni_aio_finish_error(aio, rv);
}
|
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
movq %r14, %rdi
callq 0x171be
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf033
addq $0xa0, %r12
movq %r12, %rdi
movl %ebx, %esi
callq 0xeede
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x171be
|
/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
// be canceled too.
if (nni_list_first(&p->recvq) == aio) {
nni_aio_abort(&p->rxaio, rv);
nni_mtx_unlock(&p->mtx);
return;
}
nni_aio_list_remove(aio);
nni_mtx_unlock(&p->mtx);
nni_aio_finish_error(aio, rv);
}
|
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
movq %r14, %rdi
callq 0x171be
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf033
addq $0x268, %r12 # imm = 0x268
movq %r12, %rdi
movl %ebx, %esi
callq 0xeede
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x171be
nop
|
/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_unlock(&nni_inproc.mx);
nni_aio_finish_error(aio, NNG_ECONNREFUSED);
return;
}
// We don't have to worry about the case where a zero timeout
// on connect was specified, as there is no option to specify
// that in the upper API.
if (!nni_aio_start(aio, inproc_ep_cancel, ep)) {
nni_mtx_unlock(&nni_inproc.mx);
return;
}
nni_list_append(&server->clients, ep);
nni_aio_list_append(&ep->aios, aio);
inproc_accept_clients(server);
nni_mtx_unlock(&nni_inproc.mx);
}
|
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 (%r14), %rsi
callq 0x95d0
testl %eax, %eax
je 0x208fb
movq %r12, %rdi
movq %r15, %rsi
callq 0x11361
jmp 0x208b8
leaq 0x331e5(%rip), %rdi # 0x53ac8
callq 0x171be
pushq $0x6
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf033
leaq 0x1b2(%rip), %rsi # 0x20ab4
movq %rbx, %rdi
movq %r14, %rdx
callq 0xece6
testb %al, %al
je 0x20934
leaq 0x68(%r15), %rdi
movq %r14, %rsi
callq 0x11222
subq $-0x80, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf0a5
movq %r15, %rdi
callq 0x20b12
leaq 0x3318d(%rip), %rdi # 0x53ac8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x171be
|
/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->clients)) != NULL) {
while ((aio = nni_list_first(&client->aios)) != NULL) {
inproc_conn_finish(aio, NNG_ECONNREFUSED, ep, NULL);
}
nni_list_remove(&ep->clients, client);
}
while ((aio = nni_list_first(&ep->aios)) != NULL) {
inproc_conn_finish(aio, NNG_ECLOSED, ep, NULL);
}
nni_mtx_unlock(&nni_inproc.mx);
}
|
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 0x113aa
leaq 0x68(%rbx), %r14
pushq $0x6
popq %r15
movq %r14, %rdi
callq 0x111f5
testq %rax, %rax
je 0x209d2
movq %rax, %r12
movq %rax, %r13
subq $-0x80, %r13
movq %r13, %rdi
callq 0x111f5
testq %rax, %rax
je 0x209c5
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x20d9e
jmp 0x209a6
movq %r14, %rdi
movq %r12, %rsi
callq 0x113aa
jmp 0x2098f
leaq 0x80(%rbx), %r14
pushq $0x7
popq %r15
movq %r14, %rdi
callq 0x111f5
testq %rax, %rax
je 0x209fc
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x20d9e
jmp 0x209dd
leaq 0x330c5(%rip), %rdi # 0x53ac8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x171be
|
/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(%rsp), %xmm3
testl %r12d, %r12d
jle 0xd283
movaps %xmm0, %xmm2
movq %r14, %rax
movq (%r15), %rcx
movq %rcx, 0x18(%rsp)
shrq $0x20, %r14
shufps $0x55, %xmm2, %xmm0 # xmm0 = xmm0[1,1],xmm2[1,1]
movaps %xmm0, 0x60(%rsp)
movaps %xmm3, %xmm0
shufps $0x55, %xmm3, %xmm0 # xmm0 = xmm0[1,1],xmm3[1,1]
movaps %xmm0, 0x50(%rsp)
movl %eax, %r13d
movl %r12d, %ecx
movq %rcx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movl %eax, %r12d
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
movq %r14, 0x20(%rsp)
imulq %r13, %r14
shlq $0x2, %r14
movq %r14, 0x28(%rsp)
shlq $0x2, %r13
movq $0x0, (%rsp)
movaps %xmm2, 0x70(%rsp)
cmpl $0x0, 0x20(%rsp)
jle 0xd263
xorps %xmm1, %xmm1
cvtsi2ssl (%rsp), %xmm1
mulss 0x10(%rsp), %xmm1
addss 0xc(%rsp), %xmm1
movq 0x18(%rsp), %r15
xorl %ebp, %ebp
movss %xmm1, 0x14(%rsp)
cmpl $0x0, 0x38(%rsp)
jle 0xd256
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
mulss 0x50(%rsp), %xmm0
addss 0x60(%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
mulss %xmm3, %xmm0
addss %xmm2, %xmm0
unpcklps 0x80(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movss 0x14(%rsp), %xmm1
movaps 0x70(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
movss %xmm0, (%r15,%r14,4)
incq %r14
cmpq %r14, %r12
jne 0xd217
incq %rbp
addq %r13, %r15
cmpq 0x20(%rsp), %rbp
jne 0xd1f2
movq (%rsp), %rcx
incq %rcx
movq 0x28(%rsp), %rax
addq %rax, 0x18(%rsp)
movq %rcx, (%rsp)
cmpq 0x30(%rsp), %rcx
jne 0xd1c6
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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[i]) {
#if defined(NDEBUG)
throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
#else
std::array<std::string, size> argtypes { {type_id<Args>()...} };
throw cast_error("make_tuple(): unable to convert argument of type '" +
argtypes[i] + "' to Python object");
#endif
}
}
tuple result(size);
int counter = 0;
for (auto &arg_value : args)
PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
return result;
}
|
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
testb $0x4, 0xab(%rdx)
je 0x154bb
movq %rax, 0x18(%rcx)
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48(%rsp), %rdi
callq 0x142d9
movl $0x10, %edi
callq 0xb310
movq %rax, %rbx
leaq 0x2648f(%rip), %rsi # 0x3b909
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xb700
leaq 0x264ac(%rip), %rsi # 0x3b93c
leaq 0x28(%rsp), %rdi
callq 0xbf80
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x154da
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x154e7
leaq 0x2648d(%rip), %rdi # 0x3b94f
leaq 0x264a2(%rip), %rsi # 0x3b96b
leaq 0x26511(%rip), %rcx # 0x3b9e1
movl $0x3d9, %edx # imm = 0x3D9
callq 0xb470
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xb980
leaq 0x3cd13(%rip), %rax # 0x52228
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x3cc9f(%rip), %rsi # 0x521c0
movq 0x3da10(%rip), %rdx # 0x52f38
movq %rbx, %rdi
callq 0xbdc0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x15552
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x15552
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x15575
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x15575
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x15582
movq %rbx, %rdi
callq 0xb510
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x155a4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x155a4
jmp 0x155a1
movq %rax, %r14
movq %rsp, %rdi
callq 0x149d2
movq %r14, %rdi
callq 0xbe20
|
/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, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
/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)
pybind11_fail("scoped_acquire::dec_ref(): reference count underflow!");
#endif
if (tstate->gilstate_counter == 0) {
#if !defined(NDEBUG)
if (!release)
pybind11_fail("scoped_acquire::dec_ref(): internal error!");
#endif
PyThreadState_Clear(tstate);
if (active)
PyThreadState_DeleteCurrent();
PYBIND11_TLS_DELETE_VALUE(detail::get_internals().tstate);
release = false;
}
}
|
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 0xbaa0
movb $0x0, 0x8(%rbx)
popq %rbx
retq
leaq 0x24e75(%rip), %rdi # 0x3bb92
callq 0x14b04
leaq 0x24ea2(%rip), %rdi # 0x3bbcb
callq 0x14b04
leaq 0x24ecc(%rip), %rdi # 0x3bc01
callq 0x14b04
|
/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, 0);
detail::values_and_holders vhs(this);
auto it = vhs.find(find_type);
if (it != vhs.end())
return *it;
if (!throw_if_missing)
return value_and_holder();
#if defined(NDEBUG)
pybind11_fail("pybind11::detail::instance::get_value_and_holder: "
"type is not a pybind11 base of the given instance "
"(compile in debug mode for type details)");
#else
pybind11_fail("pybind11::detail::instance::get_value_and_holder: `" +
get_fully_qualified_tp_name(find_type->type) + "' is not a pybind11 base of the given `" +
get_fully_qualified_tp_name(Py_TYPE(this)) + "' instance");
#endif
}
|
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(%r12)
leaq 0xc8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1ce2e
movq 0x8(%r12), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x3, %rcx
cmpq %rcx, 0x18(%r13)
jne 0x1c998
testb %bpl, %bpl
jne 0x1c9c6
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
jmp 0x1c9ad
movq %rbx, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, 0x10(%r14)
testb $0x2, 0x30(%rbx)
jne 0x1c98e
movq 0x10(%rbx), %rbx
jmp 0x1c992
addq $0x10, %rbx
movq %rbx, 0x18(%r14)
jmp 0x1c9b1
movups 0xd8(%rsp), %xmm0
movups 0xe8(%rsp), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq %r14, %rax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rax
movq 0x18(%rax), %rsi
leaq 0xa8(%rsp), %r14
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xbd90
leaq 0x1fa8b(%rip), %rsi # 0x3c474
leaq 0x68(%rsp), %rdi
movq %r14, %rdx
callq 0xbd60
leaq 0x1faab(%rip), %rsi # 0x3c4a8
leaq 0x68(%rsp), %rdi
callq 0xbf80
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1ca28
movups (%rcx), %xmm0
movups %xmm0, (%r14)
jmp 0x1ca35
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xbd90
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xb640
leaq 0x1fa4e(%rip), %rsi # 0x3c4d0
leaq 0x88(%rsp), %rdi
callq 0xbf80
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1cab0
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x1cabd
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x1a0c7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cafd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x1cafd
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cb23
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x1cb23
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cb43
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x1cb43
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1cb5f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x1cb5f
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cb7f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x1cb7f
movq %rax, %rbx
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1cba0
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0xb800
movq %rbx, %rdi
callq 0xbe20
|
/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())) {
for (auto &c : parent_tinfo->implicit_casts) {
if (c.first == tinfo->cpptype) {
auto *parentptr = c.second(valueptr);
if (parentptr != valueptr)
f(parentptr, self);
traverse_offset_bases(parentptr, parent_tinfo, self, f);
break;
}
}
}
}
}
|
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 $0x2, 0xab(%rax)
je 0x1f0f3
movq (%r14), %r14
movq %rsp, %rdi
callq 0x1e3ee
movq %rax, %r13
cmpq %r13, %r14
je 0x1f169
movq (%r14), %rdi
callq 0x1c8c8
movq %rax, %rbp
testq %rax, %rax
je 0x1f163
movq 0x58(%rbp), %rax
movq 0x60(%rbp), %rcx
cmpq %rcx, %rax
je 0x1f163
movq 0x8(%r15), %rdx
cmpq %rdx, (%rax)
je 0x1f134
addq $0x10, %rax
cmpq %rcx, %rax
jne 0x1f124
jmp 0x1f163
movq %r12, %rdi
callq *0x8(%rax)
movq %rax, %rbx
cmpq %r12, %rax
je 0x1f14e
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq *0x10(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x1f0a7
addq $0x8, %r14
jmp 0x1f0fe
movq %rsp, %rdi
callq 0x149d2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f184
jmp 0x1f184
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
nop
|
/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:
dimensions: Number of cells along each dimension.
offsets: Start of the domain.
extents: Size of the domain.
)")
.def("get", (std::vector<real>& (Grid::*)()) &Grid::getData, R"(
Returns a list of all values in a flatten array.
)")
.def("get", (const std::vector<real>& (Grid::*)() const) &Grid::getData, R"(
Returns a list of all values in a flatten array (const).
)")
.def("dump", [](const Grid *g, std::string name) {io::dumpGrid(std::move(name), g);},
"name"_a, R"(
Dump the data to a file.
Supported format: .bov, .vtk, .sdf
Args:
name: Filename (with the desired extension) to dump to.
)")
.def("evaluate_sdf", [](Grid *grid, const sdf::Sdf *sdf) {evaluateAtGridPoints(sdf, grid);})
.def("evaluate_sdf_periodic", [](Grid *grid, const sdf::Sdf *sdf) {evaluateAtGridPointsPeriodic(sdf, grid);})
.def("flip", &Grid::flip,
"map"_a, R"(
Flip axes of the grid according to map.
Args:
map: The flip map description.
examples:
* map = 'xyz' does not flip anything
* map = 'yxz' flip x and y axes
* map = 'zxy' z -> x, y -> z, x -> y
)")
.def("extrude", &Grid::extrude,
"zoffset"_a, "zextent"_a, "nz"_a, R"(
Extrude a SDF from 'xy' plane to 3 dimensions.
Args:
zoffset: Offset in the new direction.
zextent: Extent in the new direction.
nz: Resolution in new direction.
)");
}
|
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, %al
movb %al, 0x8(%r8)
leaq 0x1d560(%rip), %rcx # 0x3cdaa
leaq 0xa8(%rsp), %r9
movq %rcx, (%r9)
movb %al, 0x8(%r9)
leaq 0x1d552(%rip), %rcx # 0x3cdb2
leaq 0x98(%rsp), %r10
movq %rcx, (%r10)
movb %al, 0x8(%r10)
leaq 0x1d544(%rip), %rax # 0x3cdba
leaq 0x1c5f8(%rip), %rsi # 0x3be75
leaq 0x68(%rsp), %rdx
leaq 0x58(%rsp), %rcx
movq %rbx, %rdi
pushq %rax
pushq %r10
callq 0x2337e
addq $0x10, %rsp
leaq -0xfb9f(%rip), %rax # 0xfcfe
leaq 0x68(%rsp), %rdx
movq %rax, (%rdx)
movq $0x0, 0x8(%rdx)
leaq 0x1d5f8(%rip), %rsi # 0x3ceac
leaq 0x1d5f5(%rip), %rcx # 0x3ceb0
leaq 0x40(%rsp), %rdi
callq 0x2026c
leaq -0xfbca(%rip), %rcx # 0xfd02
leaq 0x58(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x0, 0x8(%rdx)
leaq 0x1d5c9(%rip), %rsi # 0x3ceac
leaq 0x1d60d(%rip), %rcx # 0x3cef7
movq %rax, %rdi
callq 0x20360
movq %rax, %rbx
leaq 0x1c71e(%rip), %rax # 0x3c01a
movq %rax, 0x48(%rsp)
movb $0x2, 0x50(%rsp)
movq (%rbx), %r14
movq 0x335b8(%rip), %r13 # 0x52ec8
movq %r13, 0x30(%rsp)
incq (%r13)
leaq 0x1d626(%rip), %r15 # 0x3cf46
movq %r14, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x1f937
movq %rax, 0x10(%rsp)
jmp 0x1f945
callq 0xb780
movq %r13, 0x10(%rsp)
incq (%r13)
movq 0x10(%rsp), %rbp
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x18208
movq 0x20(%rsp), %r12
leaq 0x594(%rip), %rax # 0x1fefe
movq %rax, 0x30(%r12)
movq %r15, (%r12)
orb $0x10, 0x59(%r12)
movq %r14, 0x70(%r12)
movq %rbp, 0x78(%r12)
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x23a62
leaq 0x1d5b4(%rip), %rax # 0x3cf4b
movq %rax, 0x8(%r12)
leaq 0x1e0cd(%rip), %rdx # 0x3da70
leaq 0x329ee(%rip), %rcx # 0x52398
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movl $0x2, %r8d
callq 0x1824e
leaq 0x20(%rsp), %rdi
callq 0x19c8a
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x30(%rsp), %rdi
callq 0x149d2
leaq 0x1d564(%rip), %rsi # 0x3cf46
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x234d7
movq %rsp, %rdi
callq 0x149d2
movq (%rbx), %r14
movq %r13, 0x30(%rsp)
incq (%r13)
leaq 0x1d5f4(%rip), %r15 # 0x3cffc
movq %r14, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x1fa1f
movq %rax, 0x10(%rsp)
jmp 0x1fa2d
callq 0xb780
movq %r13, 0x10(%rsp)
incq (%r13)
movq 0x10(%rsp), %r12
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x18208
leaq 0x20(%rsp), %rsi
movq (%rsi), %rax
leaq 0x645(%rip), %rcx # 0x2009a
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
orb $0x10, 0x59(%rax)
movq %r14, 0x70(%rax)
movq %r12, 0x78(%rax)
leaq 0x1e016(%rip), %rdx # 0x3da85
leaq 0x32932(%rip), %rcx # 0x523a8
movq %rsp, %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x20(%rsp), %rdi
callq 0x19c8a
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x30(%rsp), %rdi
callq 0x149d2
leaq 0x1d553(%rip), %rsi # 0x3cffc
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x234d7
movq %rsp, %rdi
callq 0x149d2
movq (%rbx), %r14
movq %r13, 0x30(%rsp)
incq (%r13)
leaq 0x1d53a(%rip), %r15 # 0x3d009
movq %r14, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x1fae6
movq %rax, 0x10(%rsp)
jmp 0x1faf4
callq 0xb780
movq %r13, 0x10(%rsp)
incq (%r13)
movq 0x10(%rsp), %r12
movq %rsp, %rsi
movq $0x0, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x18208
leaq 0x20(%rsp), %rsi
movq (%rsi), %rax
leaq 0x610(%rip), %rcx # 0x2012c
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
orb $0x10, 0x59(%rax)
movq %r14, 0x70(%rax)
movq %r12, 0x78(%rax)
leaq 0x1df62(%rip), %rdx # 0x3da98
leaq 0x32883(%rip), %rcx # 0x523c0
movq %rsp, %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x20(%rsp), %rdi
callq 0x19c8a
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x30(%rsp), %rdi
callq 0x149d2
leaq 0x1d499(%rip), %rsi # 0x3d009
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x234d7
movq %rsp, %r14
movq %r14, %rdi
callq 0x149d2
leaq -0xfe87(%rip), %rax # 0xfd06
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
movq $0x0, 0x8(%rdx)
leaq 0x1d480(%rip), %rax # 0x3d024
movq %rax, (%r14)
movb $0x2, 0x8(%r14)
leaq 0x1d46c(%rip), %rsi # 0x3d01f
leaq 0x1d46e(%rip), %r8 # 0x3d028
movq %rsp, %rcx
movq %rbx, %rdi
callq 0x20454
leaq -0xfae6(%rip), %rcx # 0x100e6
leaq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x0, 0x8(%rdx)
leaq 0x1d570(%rip), %rsi # 0x3d153
leaq 0x30(%rsp), %rcx
movq %rsi, (%rcx)
movb $0x2, %sil
movb %sil, 0x8(%rcx)
leaq 0x1d562(%rip), %rdi # 0x3d15b
leaq 0x88(%rsp), %r8
movq %rdi, (%r8)
movb %sil, 0x8(%r8)
leaq 0x1d554(%rip), %rdi # 0x3d163
leaq 0x78(%rsp), %r9
movq %rdi, (%r9)
movb %sil, 0x8(%r9)
subq $0x8, %rsp
leaq 0x1d540(%rip), %r10 # 0x3d166
leaq 0x1d51e(%rip), %rsi # 0x3d14b
movq %rax, %rdi
pushq %r10
callq 0x2054a
addq $0x10, %rsp
leaq 0x40(%rsp), %rdi
callq 0x149d2
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1fcaa
jmp 0x1fcaa
jmp 0x1fc99
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x19c8a
jmp 0x1fc6f
movq %rax, %rbx
jmp 0x1fc85
jmp 0x1fc99
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x19c8a
jmp 0x1fc85
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
jmp 0x1fcda
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x1fcdf
movq %rax, %rbx
jmp 0x1fcc8
jmp 0x1fcaa
jmp 0x1fcaa
movq %rax, %rbx
jmp 0x1fce4
jmp 0x1fcb1
movq %rax, %rbx
jmp 0x1fcda
movq %rax, %rbx
jmp 0x1fcda
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x19c8a
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x30(%rsp), %rdi
callq 0x149d2
leaq 0x40(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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), %rsi
incq %rsi
callq 0xb800
movq %r14, %rdi
callq 0xbe20
|
/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>());
v_h.set_holder_constructed();
} else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
v_h.set_holder_constructed();
}
}
|
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), %rcx
orb $0x1, (%rax,%rcx)
retq
orb $0x4, %cl
movb %cl, 0x30(%rax)
retq
|
/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, %rdi
movq %rbx, %rdx
callq 0x21fee
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x21fbc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x21fbc
movq 0x30f1b(%rip), %rbx # 0x52ec8
movq %rsp, %rdi
movq %rbx, (%rdi)
addq $0x2, (%rbx)
callq 0x149d2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x21fe5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb800
movq %rbx, %rdi
callq 0xbe20
nop
|
/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 *) type.ptr());
if (tinfo && tinfo->get_buffer)
break;
}
if (view == nullptr || !tinfo || !tinfo->get_buffer) {
if (view)
view->obj = nullptr;
PyErr_SetString(PyExc_BufferError, "pybind11_getbuffer(): Internal error");
return -1;
}
std::memset(view, 0, sizeof(Py_buffer));
buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data);
if ((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE && info->readonly) {
delete info;
// view->obj = nullptr; // Was just memset to 0, so not necessary
PyErr_SetString(PyExc_BufferError, "Writable buffer requested for readonly storage");
return -1;
}
view->obj = obj;
view->ndim = 1;
view->internal = info;
view->buf = info->ptr;
view->itemsize = info->itemsize;
view->len = view->itemsize;
for (auto s : info->shape)
view->len *= s;
view->readonly = info->readonly;
if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
view->format = const_cast<char *>(info->format.c_str());
if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
view->ndim = (int) info->ndim;
view->strides = &info->strides[0];
view->shape = &info->shape[0];
}
Py_INCREF(view->obj);
return 0;
}
|
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
movq (%r13), %r13
movq %rsp, %rdi
callq 0x1e3ee
movq %rax, %r12
cmpq %rax, %r13
je 0x22309
movq (%r13), %rdi
callq 0x1c8c8
movq %rax, %r15
testq %rax, %rax
je 0x222fe
cmpq $0x0, 0x78(%r15)
jne 0x2230c
addq $0x8, %r13
cmpq %r12, %r13
jne 0x222e6
jmp 0x2230c
xorl %r15d, %r15d
movq %rsp, %rdi
callq 0x149d2
testq %rbx, %rbx
je 0x22386
testq %r15, %r15
je 0x22386
cmpq $0x0, 0x78(%r15)
je 0x22386
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x80(%r15), %rsi
movq %r14, %rdi
callq *0x78(%r15)
movq %rax, %r15
testb $0x1, %bpl
je 0x223b0
cmpb $0x1, 0x70(%r15)
jne 0x223b0
testq %r15, %r15
je 0x22373
movq %r15, %rdi
callq 0x22472
movl $0x88, %esi
movq %r15, %rdi
callq 0xb800
movq 0x30bc6(%rip), %rax # 0x52f40
movq (%rax), %rdi
leaq 0x1b181(%rip), %rsi # 0x3d505
jmp 0x223a4
testq %rbx, %rbx
je 0x22393
movq $0x0, 0x8(%rbx)
movq 0x30ba6(%rip), %rax # 0x52f40
movq (%rax), %rdi
leaq 0x1b13c(%rip), %rsi # 0x3d4e0
callq 0xb8d0
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x2242c
movq %r14, 0x8(%rbx)
movl $0x1, 0x24(%rbx)
movq %r15, 0x48(%rbx)
movq (%r15), %rax
movq %rax, (%rbx)
movq 0x8(%r15), %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movq 0x40(%r15), %rax
movq 0x48(%r15), %rcx
cmpq %rcx, %rax
je 0x223f6
movq 0x10(%rbx), %rdx
movq %rax, %rsi
imulq (%rsi), %rdx
movq %rdx, 0x10(%rbx)
addq $0x8, %rsi
cmpq %rcx, %rsi
jne 0x223e5
movzbl 0x70(%r15), %ecx
movl %ecx, 0x20(%rbx)
testb $0x4, %bpl
je 0x2240c
movq 0x18(%r15), %rcx
movq %rcx, 0x28(%rbx)
notl %ebp
testb $0x18, %bpl
jne 0x22427
movl 0x38(%r15), %ecx
movl %ecx, 0x24(%rbx)
movq 0x58(%r15), %rcx
movq %rcx, 0x38(%rbx)
movq %rax, 0x30(%rbx)
incq (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2243d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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;
}
}
return false;
}
|
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, %r15d
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x22d2c
testb %al, %al
jne 0x23206
addq $0x10, %r13
leaq 0x10(%rsp), %r12
cmpq %rbx, %r13
setne %bpl
je 0x23218
movq (%r13), %rsi
movq %r12, %rdi
callq 0x2333a
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x22d2c
addq $0x10, %r13
testb %al, %al
je 0x231d7
addq $-0x10, %r13
movq 0x20(%rsp), %rdi
callq *0x8(%r13)
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 "
"of temporary values");
auto &list_ptr = stack.back();
if (list_ptr == nullptr) {
list_ptr = PyList_New(1);
if (!list_ptr)
pybind11_fail("loader_life_support: error allocating list");
PyList_SET_ITEM(list_ptr, 0, h.inc_ref().ptr());
} else {
auto result = PyList_Append(list_ptr, h.ptr());
if (result == -1)
pybind11_fail("loader_life_support: error adding patient");
}
}
|
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, -0x8(%r14)
testq %rax, %rax
je 0x232d1
testq %rbx, %rbx
je 0x23283
incq (%rbx)
movq 0x8(%rax), %rcx
testb $0x2, 0xab(%rcx)
je 0x232dd
movq 0x18(%rax), %rax
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb310
movq %rax, %rbx
leaq 0x1a281(%rip), %rsi # 0x3d534
movq %rax, %rdi
callq 0x23368
leaq 0x2eefe(%rip), %rsi # 0x521c0
movq 0x2fc6f(%rip), %rdx # 0x52f38
movq %rbx, %rdi
callq 0xbdc0
leaq 0x1a2e0(%rip), %rdi # 0x3d5b8
callq 0x14b04
leaq 0x1a2ff(%rip), %rdi # 0x3d5e3
leaq 0x1a30f(%rip), %rsi # 0x3d5fa
leaq 0x1a391(%rip), %rcx # 0x3d683
movl $0x45, %edx
callq 0xb470
movq %rax, %r14
movq %rbx, %rdi
callq 0xb510
movq %r14, %rdi
callq 0xbe20
nop
|
/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::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [242])::'lambda'(pybind11::detail::value_and_holder&, sdf_tools::int3, sdf_tools::real3, sdf_tools::real3), pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg, char [242]>(char const*, pybind11::class_<sdf_tools::Grid>&&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [242])
|
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)
callq 0xb1e0
testq %rax, %rax
je 0x233cc
movq %rax, (%rsp)
jmp 0x233d8
callq 0xb780
movq %r15, (%rsp)
incq (%r15)
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %r10
movq (%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rcx, (%r8)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbp, %rsi
movq %r13, %r9
pushq %rax
pushq %r10
pushq %r12
pushq 0x30(%rsp)
callq 0x23480
addq $0x20, %rsp
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x23472
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
jmp 0x2346d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
nop
|
/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 %rcx, -0x8(%r15)
movq %rax, (%r15)
xorl %eax, %eax
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x20(%rsp), %r13
movq %rax, (%r13)
callq 0x149d2
movq -0x10(%r13), %rdi
movq -0x8(%r13), %rsi
movq (%r12), %rdx
callq 0x23f78
movq %r13, %rdi
callq 0x149d2
movq %r15, %rdi
callq 0x149d2
movq %rsp, %rdi
callq 0x149d2
leaq 0x1a1d9(%rip), %rsi # 0x3d73c
movq %r14, %rdi
callq 0xbac0
movl %eax, %ebp
testl %eax, %eax
je 0x23576
xorl %r14d, %r14d
jmp 0x235ac
movq (%rbx), %rax
leaq 0x20(%rsp), %r15
movq %rax, -0x10(%r15)
leaq 0x19ce8(%rip), %rax # 0x3d271
movq %rax, -0x8(%r15)
movq $0x0, (%r15)
leaq 0x1a1a8(%rip), %rsi # 0x3d743
leaq 0x8(%rsp), %rdi
callq 0x23f00
movl %eax, %r14d
xorb $0x1, %r14b
testl %ebp, %ebp
jne 0x235ba
leaq 0x20(%rsp), %rdi
callq 0x149d2
testb %r14b, %r14b
je 0x23600
movq 0x2f902(%rip), %rdx # 0x52ec8
incq (%rdx)
movq %rdx, (%rsp)
movq (%rbx), %rdi
leaq 0x40(%rsp), %r14
movq %rdi, -0x10(%r14)
leaq 0x1a163(%rip), %rsi # 0x3d743
movq %rsi, -0x8(%r14)
movq $0x0, (%r14)
callq 0x1f7a8
movq %r14, %rdi
callq 0x149d2
movq %rsp, %rdi
callq 0x149d2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
jmp 0x23635
movq %rax, %rbx
movq %r14, %rdi
jmp 0x2362d
movq %rax, %rbx
movq %r13, %rdi
callq 0x149d2
movq %r15, %rdi
callq 0x149d2
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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 0x20(%r14), %rcx
movq 0x10(%rax), %rsi
movl (%rcx), %edx
andl $0x4, %edx
shrl $0x2, %edx
callq 0x22d2c
testb %al, %al
je 0x238a9
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x18(%rax), %rsi
movl (%rcx), %edx
andl $0x8, %edx
shrl $0x3, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22d2c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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, %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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_string<char, std::char_traits<char>, std::allocator<char>> const&), pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::arg const&, char const (&) [291])::'lambda'(sdf_tools::Grid*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&), 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_string<char, std::char_traits<char>, std::allocator<char>> const&), pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::arg const&, char const (&) [291])
|
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 in case of an exception.
auto unique_rec = make_function_record();
auto rec = unique_rec.get();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
// Pass on the ownership over the `unique_rec` to `initialize_generic`. `rec` stays valid.
initialize_generic(std::move(unique_rec), signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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
movq %rax, 0x30(%r14)
movq (%r13), %rax
movq %rax, (%r14)
orb $0x10, 0x59(%r14)
movq (%r12), %rax
movq %rax, 0x70(%r14)
movq (%r15), %rax
movq %rax, 0x78(%r14)
movq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x23a62
movq 0x48(%rsp), %rax
movq %rax, 0x8(%r14)
leaq 0x191f8(%rip), %rdx # 0x3daab
leaq 0x2db1e(%rip), %rcx # 0x523d8
movq %rsp, %rsi
movl $0x2, %r8d
movq %rbx, %rdi
callq 0x1824e
movq %rsp, %rdi
callq 0x19c8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19c8a
movq %rbx, %rdi
callq 0xbe20
nop
|
/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 const&, pybind11::sibling const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [235])::'lambda'(sdf_tools::Grid*, float, float, int), 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 const&, pybind11::sibling const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [235])
|
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 in case of an exception.
auto unique_rec = make_function_record();
auto rec = unique_rec.get();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
// Pass on the ownership over the `unique_rec` to `initialize_generic`. `rec` stays valid.
initialize_generic(std::move(unique_rec), signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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
movq %rcx, 0x30(%rax)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x50(%rsp), %r9
pushq %rax
pushq 0x60(%rsp)
callq 0x24b04
addq $0x10, %rsp
leaq 0x18fff(%rip), %rdx # 0x3dac0
leaq 0x2d920(%rip), %rcx # 0x523e8
movq %rsp, %rsi
movl $0x4, %r8d
movq %rbx, %rdi
callq 0x1824e
movq %rsp, %rdi
callq 0x19c8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19c8a
movq %rbx, %rdi
callq 0xbe20
nop
|
/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, %rdi
callq 0xb540
ucomisd 0x1807f(%rip), %xmm0 # 0x3cd60
jne 0x24d40
jp 0x24d40
movsd %xmm0, 0x8(%rsp)
callq 0xbcc0
movsd 0x8(%rsp), %xmm0
testq %rax, %rax
je 0x24d40
callq 0xb780
testb %bpl, %bpl
je 0x24d3c
movq %r14, %rdi
callq 0xb5f0
testl %eax, %eax
je 0x24d3c
movq %r14, %rdi
callq 0xb370
movq %rax, (%rsp)
callq 0xb780
movq (%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x24c96
movl %eax, %ebx
movq %rsp, %rdi
callq 0x149d2
jmp 0x24d4a
xorl %ebx, %ebx
jmp 0x24d4a
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx)
movb $0x1, %bl
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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_class<SdfBox> (m, "Box", pysdf, R"(
Box aligned with axes
)")
.def(py::init <real3, real3, bool> (),
"low"_a, "high"_a, "inside"_a, R"(
Args:
low: Lower corner of the box.
high: Upper corner of the box.
inside: ``True`` if the interior is inside the given shape.
)");
py::shared_class<SdfCapsule> (m, "Capsule", pysdf, R"(
Capsule defined by a segment and a radius.
)")
.def(py::init <real3, real3, real, bool> (),
"start"_a, "end"_a, "radius"_a, "inside"_a, R"(
Args:
start: First end of the segment.
end: Second end of the segment.
radius: Radius of the capsule.
inside: Whether the domain is inside the capsule or outside of it.
)");
py::shared_class<SdfEdges> (m, "Edges", pysdf, R"(
Closed polygon defined from edges in the xy plane.
)")
.def(py::init <std::vector<real2>&, bool, int> (),
"edges"_a, "inside"_a, "nsamples"_a = 20, R"(
Args:
edges: List of vertices positions (2D).
inside: ``True`` if the interior is inside the given shape.
nsamples: Number of samples to find the sign of the SDF (more is more accurate).
)");
py::shared_class<SdfFromMesh> (m, "FromMesh", pysdf, R"(
Closed triangle mesh.
)")
.def(py::init <std::vector<int3>, std::vector<real3>, bool> (),
"faces"_a, "vertices"_a, "inside"_a, R"(
Args:
faces: List of vertex indices forming each face.
vertices: List of vertices positions (3D).
inside: ``True`` if the interior is inside the given shape.
)");
py::shared_class<SdfPiecewisePipe> (m, "PiecewisePipe", pysdf, R"(
The union of many connected capsules, forming a piecewise linear pipe with a constant radius.
)")
.def(py::init <std::vector<real3>, real, bool> (),
"vertices"_a, "radius"_a, "inside"_a, R"(
Args:
vertices: Coordinates of the points forming the center line.
radius: Radius of the capsule.
inside: Whether the domain is inside the capsule or outside of it.
)");
py::shared_class<SdfPlate> (m, "Plate", pysdf, R"(
Plate defined by one point on the surface and the normal vector, pointing inside.
)")
.def(py::init <real3, real3> (),
"point"_a, "normal"_a, R"(
Args:
point: One point on the plane.
normal: The normal vector (not necessarily normalized, but must be non-zero)
pointing inside.
)");
py::shared_class<SdfSphere> (m, "Sphere", pysdf, R"(
Sphere defined by its center and radius.
)")
.def(py::init <real3, real, bool> (),
"center"_a, "radius"_a, "inside"_a, R"(
Args:
center: Center of the sphere.
radius: Radius of the sphere.
inside: Whether the domain is inside the sphere or outside of it.
)");
py::shared_class<SdfUnion> (m, "Union", pysdf, "Union between two SDF objects.")
.def(py::init<std::shared_ptr<Sdf>, std::shared_ptr<Sdf>>(),
"a"_a, "b"_a, R"(
Args:
a: The first sdf.
b: The second sdf.
)");
py::shared_class<SdfIntersection> (m, "Intersection", pysdf, "Intersection between two SDF objects.")
.def(py::init<std::shared_ptr<Sdf>, std::shared_ptr<Sdf>>(),
"a"_a, "b"_a, R"(
Args:
a: The first sdf.
b: The second sdf.
)");
py::shared_class<SdfDifference> (m, "Difference", pysdf, "Difference between two SDF objects.")
.def(py::init<std::shared_ptr<Sdf>, std::shared_ptr<Sdf>>(),
"a"_a, "b"_a, R"(
Args:
a: The original sdf.
b: The sdf of the object that should be removed from the original.
)");
py::shared_class<SdfSmoothUnion> (m, "SmoothUnion", pysdf, "Smooth Union between two SDF objects.")
.def(py::init<std::shared_ptr<Sdf>, std::shared_ptr<Sdf>, real>(),
"a"_a, "b"_a, "k"_a=32.0_r, R"(
Args:
a: The first sdf.
b: The second sdf.
k: The smoothing parameter. Must be positive.
)");
py::shared_class<SdfComplement> (m, "Complement", pysdf, "Reverse interior and exterior.")
.def(py::init<std::shared_ptr<Sdf>>(),
"sdf"_a, R"(
Args:
sdf: The original sdf.
)");
}
|
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 0x1948d(%rip), %rax # 0x3e33e
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
movb $0x2, 0x8(%rcx)
leaq 0x17698(%rip), %rsi # 0x3c55c
leaq 0x18c3a(%rip), %r8 # 0x3db05
movq %r14, %rdi
callq 0x258ec
movq (%rbx), %rsi
leaq 0x18caa(%rip), %rdx # 0x3db87
leaq 0x18ca7(%rip), %r8 # 0x3db8b
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x259e2
leaq 0x18cb5(%rip), %rax # 0x3dbaf
leaq 0x58(%rsp), %r8
movq %rax, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x18ca4(%rip), %rcx # 0x3dbb3
leaq 0x48(%rsp), %r9
movq %rcx, (%r9)
movb %al, 0x8(%r9)
leaq 0x18c96(%rip), %r12 # 0x3dbb8
leaq 0x18(%rsp), %r15
movq %r12, (%r15)
movb %al, 0x8(%r15)
leaq 0x18c8a(%rip), %rax # 0x3dbbf
leaq 0x16f39(%rip), %rsi # 0x3be75
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x44(%rsp), %rcx
pushq %rax
pushq %r15
callq 0x26b20
addq $0x10, %rsp
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x18d17(%rip), %rdx # 0x3dc85
leaq 0x18d18(%rip), %r8 # 0x3dc8d
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x25aac
leaq 0x18d3c(%rip), %rax # 0x3dcc7
leaq 0x58(%rsp), %r8
movq %rax, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x16239(%rip), %rcx # 0x3b1d9
leaq 0x48(%rsp), %r9
movq %rcx, (%r9)
movb %al, 0x8(%r9)
leaq 0x18d1a(%rip), %r13 # 0x3dccd
movq %r13, 0x18(%rsp)
movb %al, 0x20(%rsp)
movq %r12, 0x30(%rsp)
movb %al, 0x38(%rsp)
subq $0x8, %rsp
leaq 0x18d04(%rip), %rax # 0x3dcd4
leaq 0x16e9e(%rip), %rsi # 0x3be75
leaq 0x18(%rsp), %rdi
leaq 0x4c(%rsp), %rdx
leaq 0x17(%rsp), %rcx
pushq %rax
pushq %r14
pushq %r15
callq 0x2722a
addq $0x20, %rsp
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x18dcd(%rip), %rdx # 0x3ddd5
leaq 0x18dcc(%rip), %r8 # 0x3dddb
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x25b76
leaq 0x18df7(%rip), %rax # 0x3de1c
movq %rax, 0x18(%rsp)
movb $0x2, %al
movb %al, 0x20(%rsp)
movq %r12, 0x30(%rsp)
movb %al, 0x38(%rsp)
leaq 0x44(%rsp), %rdx
movl $0x14, (%rdx)
leaq 0x18dd7(%rip), %rcx # 0x3de22
leaq 0x48(%rsp), %rsi
movq %rcx, (%rsi)
movb %al, 0x8(%rsi)
leaq 0x58(%rsp), %r15
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x27994
leaq 0x18dbf(%rip), %rax # 0x3de2b
leaq 0x16e02(%rip), %rsi # 0x3be75
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0x18(%rsp), %r14
leaq 0x30(%rsp), %r9
movq %r14, %r8
pushq %rax
pushq %r15
callq 0x27a48
addq $0x10, %rsp
leaq 0x88(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x250bc
movq 0x88(%rsp), %rsi
incq %rsi
callq 0xb800
leaq 0x68(%rsp), %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x18e53(%rip), %rdx # 0x3df2d
leaq 0x18e55(%rip), %r8 # 0x3df36
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x25c6a
leaq 0x18e63(%rip), %rax # 0x3df5a
leaq 0x58(%rsp), %r8
movq %rax, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x18e54(%rip), %rbp # 0x3df60
leaq 0x48(%rsp), %r9
movq %rbp, (%r9)
movb %al, 0x8(%r9)
movq %r12, 0x18(%rsp)
movb %al, 0x20(%rsp)
leaq 0x18e41(%rip), %rax # 0x3df69
leaq 0x16d46(%rip), %rsi # 0x3be75
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x44(%rsp), %rcx
pushq %rax
pushq %r14
callq 0x28f3c
addq $0x10, %rsp
leaq 0x30(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x18ef0(%rip), %rdx # 0x3e04e
leaq 0x18ef7(%rip), %r8 # 0x3e05c
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x25d34
leaq 0x58(%rsp), %r8
movq %rbp, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x48(%rsp), %r9
movq %r13, (%r9)
movb %al, 0x8(%r9)
movq %r12, 0x18(%rsp)
movb %al, 0x20(%rsp)
leaq 0x18f2b(%rip), %rax # 0x3e0c9
leaq 0x16cd0(%rip), %rsi # 0x3be75
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x44(%rsp), %rcx
pushq %rax
pushq %r14
callq 0x29f7a
addq $0x10, %rsp
leaq 0x30(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x18fe1(%rip), %rdx # 0x3e1b5
leaq 0x18fe0(%rip), %r8 # 0x3e1bb
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x25dfe
leaq 0x1902b(%rip), %rax # 0x3e21c
leaq 0x58(%rsp), %r8
movq %rax, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x1901c(%rip), %rcx # 0x3e222
leaq 0x48(%rsp), %r9
movq %rcx, (%r9)
movb %al, 0x8(%r9)
subq $0x8, %rsp
leaq 0x1900c(%rip), %rax # 0x3e229
leaq 0x16c51(%rip), %rsi # 0x3be75
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rdx
leaq 0x18(%rsp), %rcx
pushq %rax
callq 0x2a6ca
addq $0x10, %rsp
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x190a6(%rip), %rdx # 0x3e2fa
leaq 0x190a6(%rip), %r8 # 0x3e301
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x25ec8
leaq 0x190c8(%rip), %rax # 0x3e339
leaq 0x58(%rsp), %r8
movq %rax, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x48(%rsp), %r9
movq %r13, (%r9)
movb %al, 0x8(%r9)
movq %r12, 0x18(%rsp)
movb %al, 0x20(%rsp)
leaq 0x190a5(%rip), %rax # 0x3e340
leaq 0x16bd3(%rip), %rsi # 0x3be75
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x44(%rsp), %rcx
pushq %rax
pushq %r14
callq 0x2ad54
addq $0x10, %rsp
leaq 0x30(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x19285(%rip), %rdx # 0x3e556
leaq 0x1928b(%rip), %r8 # 0x3e563
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x25f92
leaq 0x1911d(%rip), %r14 # 0x3e40b
leaq 0x58(%rsp), %r8
movq %r14, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x15fb6(%rip), %r12 # 0x3b2b9
leaq 0x48(%rsp), %r9
movq %r12, (%r9)
movb %al, 0x8(%r9)
subq $0x8, %rsp
leaq 0x190f3(%rip), %r13 # 0x3e40d
leaq 0x16b54(%rip), %rsi # 0x3be75
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rdx
leaq 0x18(%rsp), %rcx
pushq %r13
callq 0x2b42c
addq $0x10, %rsp
leaq 0x18(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x19115(%rip), %rdx # 0x3e464
leaq 0x1911b(%rip), %r8 # 0x3e471
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x2605c
leaq 0x58(%rsp), %r8
movq %r14, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x48(%rsp), %r9
movq %r12, (%r9)
movb %al, 0x8(%r9)
subq $0x8, %rsp
leaq 0x16aeb(%rip), %rsi # 0x3be75
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rdx
leaq 0x18(%rsp), %rcx
pushq %r13
callq 0x2c1b8
addq $0x10, %rsp
leaq 0x18(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x190df(%rip), %rdx # 0x3e497
leaq 0x190e3(%rip), %r8 # 0x3e4a2
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x26126
leaq 0x58(%rsp), %r8
movq %r14, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x48(%rsp), %r9
movq %r12, (%r9)
movb %al, 0x8(%r9)
subq $0x8, %rsp
leaq 0x190d3(%rip), %rax # 0x3e4c6
leaq 0x16a7b(%rip), %rsi # 0x3be75
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rdx
leaq 0x18(%rsp), %rcx
pushq %rax
callq 0x2c8b2
addq $0x10, %rsp
leaq 0x18(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x19129(%rip), %rdx # 0x3e550
leaq 0x1912e(%rip), %r8 # 0x3e55c
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x261f0
movq %r14, 0x18(%rsp)
movb $0x2, %al
movb %al, 0x20(%rsp)
movq %r12, 0x30(%rsp)
movb %al, 0x38(%rsp)
leaq 0x44(%rsp), %rdx
movl $0x42000000, (%rdx) # imm = 0x42000000
leaq 0x15f12(%rip), %rcx # 0x3b375
leaq 0x48(%rsp), %rsi
movq %rcx, (%rsi)
movb %al, 0x8(%rsi)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x2cfac
leaq 0x190fe(%rip), %rax # 0x3e582
leaq 0x169ea(%rip), %rsi # 0x3be75
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0xf(%rsp), %rcx
leaq 0x18(%rsp), %r8
leaq 0x30(%rsp), %r9
pushq %rax
pushq %r14
callq 0x2d064
addq $0x10, %rsp
movq 0x78(%rsp), %rdi
cmpq %r15, %rdi
je 0x254ca
movq 0x88(%rsp), %rsi
incq %rsi
callq 0xb800
leaq 0x68(%rsp), %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq (%rbx), %rsi
leaq 0x1912a(%rip), %rdx # 0x3e612
leaq 0x1912e(%rip), %r8 # 0x3e61d
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x262ba
leaq 0x17b00(%rip), %rax # 0x3d005
leaq 0x58(%rsp), %r8
movq %rax, (%r8)
movb $0x2, 0x8(%r8)
leaq 0x1695c(%rip), %rsi # 0x3be75
leaq 0x1911c(%rip), %r9 # 0x3e63c
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x2d8f6
leaq 0x48(%rsp), %rdi
callq 0x149d2
leaq 0x28(%rsp), %rdi
callq 0x149d2
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x255c7
jmp 0x255d0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x25c40
jmp 0x255b6
jmp 0x255b3
jmp 0x255d0
jmp 0x25589
jmp 0x255d0
jmp 0x25589
jmp 0x255d0
jmp 0x25589
jmp 0x255d0
jmp 0x255bf
jmp 0x255d0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x255c7
jmp 0x255d0
jmp 0x255bf
jmp 0x255d0
jmp 0x255bf
jmp 0x255d0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x25c40
jmp 0x255af
movq %rax, %rbx
jmp 0x255b6
jmp 0x255d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x255c7
jmp 0x255d0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x149d2
jmp 0x255d3
jmp 0x255d0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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), %rsi
incq %rsi
callq 0xb800
movq %r14, %rdi
callq 0xbe20
|
/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), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x256d9
movq (%rbx), %rsi
incq %rsi
callq 0xb800
movq %r14, %rdi
callq 0xbe20
|
/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:
( constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
constexpr_sum(is_base<options>::value...) == 0 && // no template option bases
none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
"Error: multiple inheritance bases must be specified via class_ template options");
type_record record;
record.scope = scope;
record.name = name;
record.type = &typeid(type);
record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
record.holder_size = sizeof(holder_type);
record.init_instance = init_instance;
record.dealloc = dealloc;
record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
set_operator_new<type>(&record);
/* Register base classes specified via template arguments to class_, if any */
PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
/* Process optional arguments, if any */
process_attributes<Extra...>::init(extra..., &record);
generic_type::initialize(record);
if (has_alias) {
auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
}
}
|
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
movq %rax, -0x38(%r14)
movq $0x30, -0x30(%r14)
movq $0x8, -0x28(%r14)
movq $0x10, -0x20(%r14)
leaq 0x145d(%rip), %rax # 0x26f6c
movq %rax, -0x10(%r14)
leaq 0x1554(%rip), %rax # 0x2706e
movq %rax, -0x8(%r14)
andb $-0x9, 0x18(%r14)
movq (%r14), %rdi
movq (%r12), %rsi
callq 0xb3c0
movq %rsp, %rsi
movq %r15, 0x50(%rsi)
movq %rbx, %rdi
callq 0x2083c
movq %r14, %rdi
callq 0x149d2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x25b65
movq %rax, %r15
movq %r14, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0x149d2
movq %r15, %rdi
callq 0xbe20
nop
|
/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:
( constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
constexpr_sum(is_base<options>::value...) == 0 && // no template option bases
none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
"Error: multiple inheritance bases must be specified via class_ template options");
type_record record;
record.scope = scope;
record.name = name;
record.type = &typeid(type);
record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
record.holder_size = sizeof(holder_type);
record.init_instance = init_instance;
record.dealloc = dealloc;
record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
set_operator_new<type>(&record);
/* Register base classes specified via template arguments to class_, if any */
PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
/* Process optional arguments, if any */
process_attributes<Extra...>::init(extra..., &record);
generic_type::initialize(record);
if (has_alias) {
auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
}
}
|
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
movq %rax, -0x38(%r14)
movq $0x13b8, -0x30(%r14) # imm = 0x13B8
movq $0x8, -0x28(%r14)
movq $0x10, -0x20(%r14)
leaq 0x1afd(%rip), %rax # 0x276d6
movq %rax, -0x10(%r14)
leaq 0x1bf4(%rip), %rax # 0x277d8
movq %rax, -0x8(%r14)
andb $-0x9, 0x18(%r14)
movq (%r14), %rdi
movq (%r12), %rsi
callq 0xb3c0
movq %rsp, %rsi
movq %r15, 0x50(%rsi)
movq %rbx, %rdi
callq 0x2083c
movq %r14, %rdi
callq 0x149d2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x25c2f
movq %rax, %r15
movq %r14, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0x149d2
movq %r15, %rdi
callq 0xbe20
nop
|
/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
{
// Workaround! See:
// https://github.com/pybind/pybind11/issues/2336
// https://github.com/pybind/pybind11/pull/2685#issuecomment-731286700
if (PyErr_Occurred()) {
PyErr_Clear();
}
}
|
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:
( constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
constexpr_sum(is_base<options>::value...) == 0 && // no template option bases
none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
"Error: multiple inheritance bases must be specified via class_ template options");
type_record record;
record.scope = scope;
record.name = name;
record.type = &typeid(type);
record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
record.holder_size = sizeof(holder_type);
record.init_instance = init_instance;
record.dealloc = dealloc;
record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
set_operator_new<type>(&record);
/* Register base classes specified via template arguments to class_, if any */
PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
/* Process optional arguments, if any */
process_attributes<Extra...>::init(extra..., &record);
generic_type::initialize(record);
if (has_alias) {
auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
}
}
|
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
movq %rax, -0x38(%r14)
movq $0x20, -0x30(%r14)
movq $0x8, -0x28(%r14)
movq $0x10, -0x20(%r14)
leaq 0x4b6b(%rip), %rax # 0x2aa96
movq %rax, -0x10(%r14)
leaq 0x4c62(%rip), %rax # 0x2ab98
movq %rax, -0x8(%r14)
andb $-0x9, 0x18(%r14)
movq (%r14), %rdi
movq (%r12), %rsi
callq 0xb3c0
movq %rsp, %rsi
movq %r15, 0x50(%rsi)
movq %rbx, %rdi
callq 0x2083c
movq %r14, %rdi
callq 0x149d2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x25f81
movq %rax, %r15
movq %r14, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0x149d2
movq %r15, %rdi
callq 0xbe20
nop
|
/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 (&) [38])
|
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:
( constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
constexpr_sum(is_base<options>::value...) == 0 && // no template option bases
none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
"Error: multiple inheritance bases must be specified via class_ template options");
type_record record;
record.scope = scope;
record.name = name;
record.type = &typeid(type);
record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
record.holder_size = sizeof(holder_type);
record.init_instance = init_instance;
record.dealloc = dealloc;
record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
set_operator_new<type>(&record);
/* Register base classes specified via template arguments to class_, if any */
PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
/* Process optional arguments, if any */
process_attributes<Extra...>::init(extra..., &record);
generic_type::initialize(record);
if (has_alias) {
auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
}
}
|
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
movq %rax, -0x38(%r14)
movq $0x30, -0x30(%r14)
movq $0x8, -0x28(%r14)
movq $0x10, -0x20(%r14)
leaq 0x6a9b(%rip), %rax # 0x2ccee
movq %rax, -0x10(%r14)
leaq 0x6b92(%rip), %rax # 0x2cdf0
movq %rax, -0x8(%r14)
andb $-0x9, 0x18(%r14)
movq (%r14), %rdi
movq (%r12), %rsi
callq 0xb3c0
movq %rsp, %rsi
movq %r15, 0x50(%rsi)
movq %rbx, %rdi
callq 0x2083c
movq %r14, %rdi
callq 0x149d2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x262a9
movq %rax, %r15
movq %r14, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0x149d2
movq %r15, %rdi
callq 0xbe20
nop
|
/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 (&) [31])
|
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:
( constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
constexpr_sum(is_base<options>::value...) == 0 && // no template option bases
none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
"Error: multiple inheritance bases must be specified via class_ template options");
type_record record;
record.scope = scope;
record.name = name;
record.type = &typeid(type);
record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
record.holder_size = sizeof(holder_type);
record.init_instance = init_instance;
record.dealloc = dealloc;
record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
set_operator_new<type>(&record);
/* Register base classes specified via template arguments to class_, if any */
PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
/* Process optional arguments, if any */
process_attributes<Extra...>::init(extra..., &record);
generic_type::initialize(record);
if (has_alias) {
auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
}
}
|
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
movq %rax, -0x38(%r14)
movq $0x20, -0x30(%r14)
movq $0x8, -0x28(%r14)
movq $0x10, -0x20(%r14)
leaq 0x7319(%rip), %rax # 0x2d636
movq %rax, -0x10(%r14)
leaq 0x7410(%rip), %rax # 0x2d738
movq %rax, -0x8(%r14)
andb $-0x9, 0x18(%r14)
movq (%r14), %rdi
movq (%r12), %rsi
callq 0xb3c0
movq %rsp, %rsi
movq %r15, 0x50(%rsi)
movq %rbx, %rdi
callq 0x2083c
movq %r14, %rdi
callq 0x149d2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x26373
movq %rax, %r15
movq %r14, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0x149d2
movq %r15, %rdi
callq 0xbe20
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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
jne 0x264e0
movq (%rcx), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x26507
callq 0xb110
jmp 0x26514
movq 0x10(%rcx), %rdi
testq %rdi, %rdi
je 0x264ee
callq 0xb5b0
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2650e
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x26514
callq 0xb800
jmp 0x26514
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x1661e
addq $0x20, %rsp
popq %rbx
retq
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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
jne 0x269be
movq (%rcx), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x269e5
callq 0xb110
jmp 0x269f2
movq 0x10(%rcx), %rdi
testq %rdi, %rdi
je 0x269cc
callq 0xb5b0
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x269ec
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x269f2
callq 0xb800
jmp 0x269f2
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x1661e
addq $0x20, %rsp
popq %rbx
retq
nop
|
/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_ptr<sdf_tools::sdf::SdfBox>>, pybind11::arg, pybind11::arg, pybind11::arg, char [198], 0>(pybind11::class_<sdf_tools::sdf::SdfBox, std::shared_ptr<sdf_tools::sdf::SdfBox>>&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [198])::'lambda'(pybind11::detail::value_and_holder&, sdf_tools::real3, sdf_tools::real3, bool), pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg, char [198]>(char const*, pybind11::class_<sdf_tools::sdf::SdfBox, std::shared_ptr<sdf_tools::sdf::SdfBox>>&&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [198])
|
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)
callq 0xb1e0
testq %rax, %rax
je 0x26b6e
movq %rax, (%rsp)
jmp 0x26b7a
callq 0xb780
movq %r15, (%rsp)
incq (%r15)
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %r10
movq (%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rcx, (%r8)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbp, %rsi
movq %r13, %r9
pushq %rax
pushq %r10
pushq %r12
pushq 0x30(%rsp)
callq 0x26c22
addq $0x20, %rsp
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x26c14
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
jmp 0x26c0f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
nop
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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 0x20(%r14), %rcx
movq 0x10(%rax), %rsi
movl (%rcx), %edx
andl $0x4, %edx
shrl $0x2, %edx
callq 0x22d2c
testb %al, %al
je 0x26ebf
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x18(%rax), %rsi
movl (%rcx), %edx
andl $0x8, %edx
shrl $0x3, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17288
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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 0x20(%r14), %rcx
movq 0x10(%rax), %rsi
movl (%rcx), %edx
andl $0x4, %edx
shrl $0x2, %edx
callq 0x22d2c
testb %al, %al
je 0x2761a
leaq 0x4(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x18(%rax), %rsi
movl (%rcx), %edx
andl $0x8, %edx
shrl $0x3, %edx
callq 0x24c96
testb %al, %al
je 0x2761a
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x20(%rax), %rsi
movl (%rcx), %edx
andl $0x10, %edx
shrl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17288
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::real3, std::allocator<sdf_tools::real3>>, bool>::execute<pybind11::class_<sdf_tools::sdf::SdfFromMesh, std::shared_ptr<sdf_tools::sdf::SdfFromMesh>>, pybind11::arg, pybind11::arg, pybind11::arg, char [229], 0>(pybind11::class_<sdf_tools::sdf::SdfFromMesh, std::shared_ptr<sdf_tools::sdf::SdfFromMesh>>&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [229])::'lambda'(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), pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg, char [229]>(char const*, pybind11::class_<sdf_tools::sdf::SdfFromMesh, std::shared_ptr<sdf_tools::sdf::SdfFromMesh>>&&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [229])
|
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)
callq 0xb1e0
testq %rax, %rax
je 0x28f8a
movq %rax, (%rsp)
jmp 0x28f96
callq 0xb780
movq %r15, (%rsp)
incq (%r15)
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %r10
movq (%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rcx, (%r8)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rbp, %rsi
movq %r13, %r9
pushq %rax
pushq %r10
pushq %r12
pushq 0x30(%rsp)
callq 0x2903e
addq $0x20, %rsp
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x29030
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
jmp 0x2902b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
nop
|
/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>>, pybind11::arg, pybind11::arg, pybind11::arg, char [229], 0>(pybind11::class_<sdf_tools::sdf::SdfFromMesh, std::shared_ptr<sdf_tools::sdf::SdfFromMesh>>&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [229])::'lambda'(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), void, 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, pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg, char [229]>(pybind11::class_<sdf_tools::sdf::SdfFromMesh, std::shared_ptr<sdf_tools::sdf::SdfFromMesh>>&&, void (*)(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), pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::detail::is_new_style_constructor const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [229])
|
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 in case of an exception.
auto unique_rec = make_function_record();
auto rec = unique_rec.get();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
// Pass on the ownership over the `unique_rec` to `initialize_generic`. `rec` stays valid.
initialize_generic(std::move(unique_rec), signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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 %rax, 0x10(%rsp)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x60(%rsp), %rcx
movq %rbp, %r8
movq 0x70(%rsp), %r9
callq 0x2914c
leaq 0x15909(%rip), %rdx # 0x3ea0d
leaq 0x2955d(%rip), %rcx # 0x52668
leaq 0x20(%rsp), %rsi
movl $0x4, %r8d
movq %rbx, %rdi
callq 0x1824e
leaq 0x20(%rsp), %rdi
callq 0x19c8a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x19c8a
movq %rbx, %rdi
callq 0xbe20
|
/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 const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [229], pybind11::detail::function_record*)
|
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, 0x78(%rbx)
orl $0x12, %eax
movw %ax, 0x59(%rbx)
movq %r8, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r15, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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, 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])...})
if (!r)
return false;
#endif
return true;
}
|
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 0x20(%r14), %rcx
movq 0x10(%rax), %rsi
movl (%rcx), %edx
andl $0x4, %edx
shrl $0x2, %edx
callq 0x29514
testb %al, %al
je 0x2931b
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x18(%rax), %rsi
movl (%rcx), %edx
andl $0x8, %edx
shrl $0x3, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17288
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [236], pybind11::detail::function_record*)
|
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, 0x78(%rbx)
orl $0x12, %eax
movw %ax, 0x59(%rbx)
movq %r8, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r15, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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();
}
init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
}
|
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 0x1c8f8
movq (%r15), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x2a468
movq 0x18(%rcx), %rax
movq 0x18(%rsp), %rcx
movb (%rax,%rcx), %al
andb $0x2, %al
jmp 0x2a46d
shrb $0x3, %al
andb $0x1, %al
testb %al, %al
jne 0x2a4e7
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rax
movq (%rax), %r12
leaq 0x8(%rsp), %r13
movq %r12, (%r13)
leaq 0x30(%rsp), %rbp
movq %r14, (%rbp)
callq 0x14436
leaq 0x70(%rax), %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x20dd8
testb $0x2, 0x90(%r15)
jne 0x2a4c5
leaq -0x9716(%rip), %rcx # 0x20da1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f0a7
movq 0x10(%rsp), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2a4e1
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
orb $0x2, (%rax,%rcx)
jmp 0x2a4e7
orb $0x8, %cl
movb %cl, 0x30(%rax)
leaq 0x10(%rsp), %rsi
movq 0x18(%rsi), %rax
movq (%rax), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2a5b8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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
jne 0x2a568
movq (%rcx), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x2a58f
callq 0xb110
jmp 0x2a59c
movq 0x10(%rcx), %rdi
testq %rdi, %rdi
je 0x2a576
callq 0xb5b0
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2a596
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x2a59c
callq 0xb800
jmp 0x2a59c
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x1661e
addq $0x20, %rsp
popq %rbx
retq
nop
|
/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>());
v_h.set_holder_constructed();
} else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
v_h.set_holder_constructed();
}
}
|
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 0x18(%rbx), %rdi
movq (%rdi), %rsi
movq %rsi, 0x8(%rdi)
addq $0x10, %rdi
callq 0x2a62c
jmp 0x2a60a
lock
incl 0x8(%rax)
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2a623
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
orb $0x1, (%rax,%rcx)
jmp 0x2a629
orb $0x4, %cl
movb %cl, 0x30(%rax)
popq %rbx
retq
nop
|
/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>());
v_h.set_holder_constructed();
} else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
v_h.set_holder_constructed();
}
}
|
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 0x18(%rbx), %rdi
movq (%rdi), %rsi
movq %rsi, 0x8(%rdi)
addq $0x10, %rdi
callq 0x2acb6
jmp 0x2ac94
lock
incl 0x8(%rax)
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2acad
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
orb $0x1, (%rax,%rcx)
jmp 0x2acb3
orb $0x4, %cl
movb %cl, 0x30(%rax)
popq %rbx
retq
nop
|
/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 const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&, char const (&) [203], pybind11::detail::function_record*)
|
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, 0x78(%rbx)
orl $0x12, %eax
movw %ax, 0x59(%rbx)
movq %r8, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r15, %rdi
movq %rbx, %rsi
callq 0x23a62
movq %r12, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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(%r14), %rcx
movq 0x10(%rax), %rsi
movl (%rcx), %edx
andl $0x4, %edx
shrl $0x2, %edx
callq 0x24c96
testb %al, %al
je 0x2b0d9
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x18(%rax), %rsi
movl (%rcx), %edx
andl $0x8, %edx
shrl $0x3, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17288
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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
jne 0x2b2ca
movq (%rcx), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x2b2f1
callq 0xb110
jmp 0x2b2fe
movq 0x10(%rcx), %rdi
testq %rdi, %rdi
je 0x2b2d8
callq 0xb5b0
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2b2f8
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x2b2fe
callq 0xb800
jmp 0x2b2fe
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x1661e
addq $0x20, %rsp
popq %rbx
retq
nop
|
/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>());
v_h.set_holder_constructed();
} else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
v_h.set_holder_constructed();
}
}
|
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 0x18(%rbx), %rdi
movq (%rdi), %rsi
movq %rsi, 0x8(%rdi)
addq $0x10, %rdi
callq 0x2b38e
jmp 0x2b36c
lock
incl 0x8(%rax)
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2b385
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
orb $0x1, (%rax,%rcx)
jmp 0x2b38b
orb $0x4, %cl
movb %cl, 0x30(%rax)
popq %rbx
retq
nop
|
/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.