name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
releaseMonitor
|
static void releaseMonitor(_GLFWwindow* window)
{
if (window->monitor->window != window)
return;
_glfwInputMonitorWindow(window->monitor, NULL);
_glfwRestoreVideoModeX11(window->monitor);
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
{
// Restore old screen saver settings
XSetScreenSaver(_glfw.x11.display,
_glfw.x11.saver.timeout,
_glfw.x11.saver.interval,
_glfw.x11.saver.blanking,
_glfw.x11.saver.exposure);
}
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
cmpq %rbx, 0x18(%rdi)
jne 0x26886
xorl %esi, %esi
callq 0x1f826
movq 0x40(%rbx), %rdi
callq 0x24cfe
leaq 0x34192(%rip), %rax # 0x5aa10
decl 0x20d20(%rax)
je 0x26888
popq %rbx
retq
movq 0x1fec0(%rax), %rdi
movl 0x20d24(%rax), %esi
movl 0x20d28(%rax), %edx
movl 0x20d2c(%rax), %ecx
movl 0x20d30(%rax), %r8d
popq %rbx
jmp 0x14a00
|
/Tigermouthbear[P]flappytiger/external/glfw/src/x11_window.c
|
glfwPlatformSetWindowPos
|
void _glfwPlatformSetWindowPos(_GLFWwindow* window, int xpos, int ypos)
{
// HACK: Explicitly setting PPosition to any value causes some WMs, notably
// Compiz and Metacity, to honor the position of unmapped windows
if (!_glfwPlatformWindowVisible(window))
{
long supplied;
XSizeHints* hints = XAllocSizeHints();
if (XGetWMNormalHints(_glfw.x11.display, window->x11.handle, hints, &supplied))
{
hints->flags |= PPosition;
hints->x = hints->y = 0;
XSetWMNormalHints(_glfw.x11.display, window->x11.handle, hints);
}
XFree(hints);
}
XMoveWindow(_glfw.x11.display, window->x11.handle, xpos, ypos);
XFlush(_glfw.x11.display);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x33e7f(%rip), %r12 # 0x5aa10
movq 0x1fec0(%r12), %rdi
movq 0x348(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x14850
cmpl $0x2, 0x5c(%r15)
je 0x26c07
callq 0x148b0
movq %rax, %r15
movq 0x1fec0(%r12), %rdi
movq 0x348(%r14), %rsi
leaq 0x8(%rsp), %rcx
movq %rax, %rdx
callq 0x14160
testl %eax, %eax
je 0x26bff
orb $0x4, (%r15)
movq $0x0, 0x8(%r15)
movq 0x1fec0(%r12), %rdi
movq 0x348(%r14), %rsi
movq %r15, %rdx
callq 0x14280
movq %r15, %rdi
callq 0x14070
movq 0x1fec0(%r12), %rdi
movq 0x348(%r14), %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x14090
movq 0x1fec0(%r12), %rdi
callq 0x14620
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/Tigermouthbear[P]flappytiger/external/glfw/src/x11_window.c
|
glfwPlatformRequestWindowAttention
|
void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
{
if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION)
return;
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION,
0, 1, 0);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x33468(%rip), %r15 # 0x5aa10
movq 0x20b20(%r15), %r13
movq 0x20b48(%r15), %r12
testq %r13, %r13
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x27634
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
xorl %ebp, %ebp
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x140e0
movl $0x21, (%rbx)
movq 0x348(%r14), %rax
movq %rax, 0x20(%rbx)
movl $0x20, 0x30(%rbx)
movq %r13, 0x28(%rbx)
movl $0x1, %eax
movq %rax, 0x38(%rbx)
movq %r12, 0x40(%rbx)
movq %rbp, 0x48(%rbx)
movq %rax, 0x50(%rbx)
movq %rbp, 0x58(%rbx)
movq 0x1fec0(%r15), %rdi
movq 0x1fed0(%r15), %rsi
movl $0x180000, %ecx # imm = 0x180000
xorl %edx, %edx
movq %rbx, %r8
callq 0x14660
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Tigermouthbear[P]flappytiger/external/glfw/src/x11_window.c
|
glfwInitEGL
|
GLFWbool _glfwInitEGL(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_EGL_LIBRARY)
_GLFW_EGL_LIBRARY,
#elif defined(_GLFW_WIN32)
"libEGL.dll",
"EGL.dll",
#elif defined(_GLFW_COCOA)
"libEGL.dylib",
#elif defined(__CYGWIN__)
"libEGL-1.so",
#else
"libEGL.so.1",
#endif
NULL
};
if (_glfw.egl.handle)
return GLFW_TRUE;
for (i = 0; sonames[i]; i++)
{
_glfw.egl.handle = _glfw_dlopen(sonames[i]);
if (_glfw.egl.handle)
break;
}
if (!_glfw.egl.handle)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "EGL: Library not found");
return GLFW_FALSE;
}
_glfw.egl.prefix = (strncmp(sonames[i], "lib", 3) == 0);
_glfw.egl.GetConfigAttrib = (PFN_eglGetConfigAttrib)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigAttrib");
_glfw.egl.GetConfigs = (PFN_eglGetConfigs)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigs");
_glfw.egl.GetDisplay = (PFN_eglGetDisplay)
_glfw_dlsym(_glfw.egl.handle, "eglGetDisplay");
_glfw.egl.GetError = (PFN_eglGetError)
_glfw_dlsym(_glfw.egl.handle, "eglGetError");
_glfw.egl.Initialize = (PFN_eglInitialize)
_glfw_dlsym(_glfw.egl.handle, "eglInitialize");
_glfw.egl.Terminate = (PFN_eglTerminate)
_glfw_dlsym(_glfw.egl.handle, "eglTerminate");
_glfw.egl.BindAPI = (PFN_eglBindAPI)
_glfw_dlsym(_glfw.egl.handle, "eglBindAPI");
_glfw.egl.CreateContext = (PFN_eglCreateContext)
_glfw_dlsym(_glfw.egl.handle, "eglCreateContext");
_glfw.egl.DestroySurface = (PFN_eglDestroySurface)
_glfw_dlsym(_glfw.egl.handle, "eglDestroySurface");
_glfw.egl.DestroyContext = (PFN_eglDestroyContext)
_glfw_dlsym(_glfw.egl.handle, "eglDestroyContext");
_glfw.egl.CreateWindowSurface = (PFN_eglCreateWindowSurface)
_glfw_dlsym(_glfw.egl.handle, "eglCreateWindowSurface");
_glfw.egl.MakeCurrent = (PFN_eglMakeCurrent)
_glfw_dlsym(_glfw.egl.handle, "eglMakeCurrent");
_glfw.egl.SwapBuffers = (PFN_eglSwapBuffers)
_glfw_dlsym(_glfw.egl.handle, "eglSwapBuffers");
_glfw.egl.SwapInterval = (PFN_eglSwapInterval)
_glfw_dlsym(_glfw.egl.handle, "eglSwapInterval");
_glfw.egl.QueryString = (PFN_eglQueryString)
_glfw_dlsym(_glfw.egl.handle, "eglQueryString");
_glfw.egl.GetProcAddress = (PFN_eglGetProcAddress)
_glfw_dlsym(_glfw.egl.handle, "eglGetProcAddress");
if (!_glfw.egl.GetConfigAttrib ||
!_glfw.egl.GetConfigs ||
!_glfw.egl.GetDisplay ||
!_glfw.egl.GetError ||
!_glfw.egl.Initialize ||
!_glfw.egl.Terminate ||
!_glfw.egl.BindAPI ||
!_glfw.egl.CreateContext ||
!_glfw.egl.DestroySurface ||
!_glfw.egl.DestroyContext ||
!_glfw.egl.CreateWindowSurface ||
!_glfw.egl.MakeCurrent ||
!_glfw.egl.SwapBuffers ||
!_glfw.egl.SwapInterval ||
!_glfw.egl.QueryString ||
!_glfw.egl.GetProcAddress)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to load required entry points");
_glfwTerminateEGL();
return GLFW_FALSE;
}
_glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
if (_glfw.egl.display == EGL_NO_DISPLAY)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to get EGL display: %s",
getEGLErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
if (!eglInitialize(_glfw.egl.display, &_glfw.egl.major, &_glfw.egl.minor))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to initialize EGL: %s",
getEGLErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
_glfw.egl.KHR_create_context =
extensionSupportedEGL("EGL_KHR_create_context");
_glfw.egl.KHR_create_context_no_error =
extensionSupportedEGL("EGL_KHR_create_context_no_error");
_glfw.egl.KHR_gl_colorspace =
extensionSupportedEGL("EGL_KHR_gl_colorspace");
_glfw.egl.KHR_get_all_proc_addresses =
extensionSupportedEGL("EGL_KHR_get_all_proc_addresses");
_glfw.egl.KHR_context_flush_control =
extensionSupportedEGL("EGL_KHR_context_flush_control");
return GLFW_TRUE;
}
|
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2f8a9(%rip), %r14 # 0x5aa10
movl $0x1, %ebx
cmpq $0x0, 0x20fb0(%r14)
jne 0x2b53a
leaq 0x25fd9(%rip), %rdi # 0x5115a
movl $0x1, %esi
callq 0x14520
movq %rax, 0x20fb0(%r14)
testq %rax, %rax
je 0x2b4ca
movl $0x1, 0x20f98(%r14)
leaq 0x25fd4(%rip), %rsi # 0x51181
movq %rax, %rdi
callq 0x148e0
movq %rax, 0x20fb8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25fca(%rip), %rsi # 0x51194
callq 0x148e0
movq %rax, 0x20fc0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25fbe(%rip), %rsi # 0x511a2
callq 0x148e0
movq %rax, 0x20fc8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25fb2(%rip), %rsi # 0x511b0
callq 0x148e0
movq %rax, 0x20fd0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25fa4(%rip), %rsi # 0x511bc
callq 0x148e0
movq %rax, 0x20fd8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f98(%rip), %rsi # 0x511ca
callq 0x148e0
movq %rax, 0x20fe0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f8b(%rip), %rsi # 0x511d7
callq 0x148e0
movq %rax, 0x20fe8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f7c(%rip), %rsi # 0x511e2
callq 0x148e0
movq %rax, 0x20ff0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f73(%rip), %rsi # 0x511f3
callq 0x148e0
movq %rax, 0x20ff8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f6b(%rip), %rsi # 0x51205
callq 0x148e0
movq %rax, 0x21000(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f63(%rip), %rsi # 0x51217
callq 0x148e0
movq %rax, 0x21008(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f60(%rip), %rsi # 0x5122e
callq 0x148e0
movq %rax, 0x21010(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f55(%rip), %rsi # 0x5123d
callq 0x148e0
movq %rax, 0x21018(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f4a(%rip), %rsi # 0x5124c
callq 0x148e0
movq %rax, 0x21020(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f40(%rip), %rsi # 0x5125c
callq 0x148e0
movq %rax, 0x21028(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25f35(%rip), %rsi # 0x5126b
callq 0x148e0
movq %rax, 0x21030(%r14)
cmpq $0x0, 0x20fb8(%r14)
setne %dl
movq 0x20fc8(%r14), %rcx
cmpq $0x0, 0x20fc0(%r14)
setne %sil
andb %dl, %sil
testq %rcx, %rcx
setne %dl
cmpq $0x0, 0x20fd0(%r14)
setne %dil
andb %dl, %dil
andb %sil, %dil
cmpq $0x0, 0x20fd8(%r14)
setne %dl
cmpq $0x0, 0x20fe0(%r14)
setne %sil
andb %dl, %sil
cmpq $0x0, 0x20fe8(%r14)
setne %dl
andb %sil, %dl
andb %dil, %dl
cmpq $0x0, 0x20ff0(%r14)
setne %sil
cmpq $0x0, 0x20ff8(%r14)
setne %dil
andb %sil, %dil
cmpq $0x0, 0x21000(%r14)
setne %sil
andb %dil, %sil
cmpq $0x0, 0x21008(%r14)
setne %dil
andb %sil, %dil
andb %dl, %dil
cmpq $0x0, 0x21010(%r14)
setne %dl
cmpq $0x0, 0x21018(%r14)
setne %sil
andb %dl, %sil
cmpq $0x0, 0x21020(%r14)
setne %dl
andb %sil, %dl
cmpq $0x0, 0x21028(%r14)
setne %sil
andb %dl, %sil
andb %dil, %sil
testq %rax, %rax
setne %al
testb %al, %sil
je 0x2b4e1
movq 0x1fec0(%r14), %rdi
callq *%rcx
movq %rax, 0x20f88(%r14)
testq %rax, %rax
je 0x2b4f8
leaq 0x20f90(%r14), %rsi
leaq 0x20f94(%r14), %rdx
movq %rax, %rdi
callq *0x20fd8(%r14)
testl %eax, %eax
je 0x2b50f
leaq 0x25e81(%rip), %rdi # 0x512ec
callq 0x2b5ab
movl %eax, 0x20f9c(%r14)
leaq 0x25e85(%rip), %rdi # 0x51303
callq 0x2b5ab
movl %eax, 0x20fa0(%r14)
leaq 0x25e92(%rip), %rdi # 0x51323
callq 0x2b5ab
movl %eax, 0x20fa4(%r14)
leaq 0x25e95(%rip), %rdi # 0x51339
callq 0x2b5ab
movl %eax, 0x20fa8(%r14)
leaq 0x25ea1(%rip), %rdi # 0x51358
callq 0x2b5ab
movl %eax, 0x20fac(%r14)
movl $0x1, %ebx
jmp 0x2b53a
leaq 0x25c95(%rip), %rsi # 0x51166
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1cdad
jmp 0x2b53a
leaq 0x25d95(%rip), %rsi # 0x5127d
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1cdad
jmp 0x2b535
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2b587
leaq 0x25d9a(%rip), %rsi # 0x512a7
jmp 0x2b524
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2b587
leaq 0x25da6(%rip), %rsi # 0x512ca
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x1cdad
callq 0x2b544
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Tigermouthbear[P]flappytiger/external/glfw/src/egl_context.c
|
getEGLErrorString
|
static const char* getEGLErrorString(EGLint error)
{
switch (error)
{
case EGL_SUCCESS:
return "Success";
case EGL_NOT_INITIALIZED:
return "EGL is not or could not be initialized";
case EGL_BAD_ACCESS:
return "EGL cannot access a requested resource";
case EGL_BAD_ALLOC:
return "EGL failed to allocate resources for the requested operation";
case EGL_BAD_ATTRIBUTE:
return "An unrecognized attribute or attribute value was passed in the attribute list";
case EGL_BAD_CONTEXT:
return "An EGLContext argument does not name a valid EGL rendering context";
case EGL_BAD_CONFIG:
return "An EGLConfig argument does not name a valid EGL frame buffer configuration";
case EGL_BAD_CURRENT_SURFACE:
return "The current surface of the calling thread is a window, pixel buffer or pixmap that is no longer valid";
case EGL_BAD_DISPLAY:
return "An EGLDisplay argument does not name a valid EGL display connection";
case EGL_BAD_SURFACE:
return "An EGLSurface argument does not name a valid surface configured for GL rendering";
case EGL_BAD_MATCH:
return "Arguments are inconsistent";
case EGL_BAD_PARAMETER:
return "One or more argument values are invalid";
case EGL_BAD_NATIVE_PIXMAP:
return "A NativePixmapType argument does not refer to a valid native pixmap";
case EGL_BAD_NATIVE_WINDOW:
return "A NativeWindowType argument does not refer to a valid native window";
case EGL_CONTEXT_LOST:
return "The application must destroy all contexts and reinitialise";
default:
return "ERROR: UNKNOWN EGL ERROR";
}
}
|
addl $0xffffd000, %edi # imm = 0xFFFFD000
cmpl $0xe, %edi
ja 0x2b5a3
movl %edi, %eax
leaq 0x26439(%rip), %rcx # 0x519d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x26354(%rip), %rax # 0x518fe
retq
|
/Tigermouthbear[P]flappytiger/external/glfw/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;
}
}
_glfwPlatformSetTls(&_glfw.contextSlot, window);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2eb7d(%rip), %r14 # 0x5aa10
movq 0x20f88(%r14), %rdi
movq 0x21010(%r14), %rax
testq %rbx, %rbx
je 0x2bed4
movq 0x288(%rbx), %rcx
movq 0x290(%rbx), %rdx
movq %rdx, %rsi
callq *%rax
testl %eax, %eax
jne 0x2bee0
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2b587
leaq 0x25a61(%rip), %rsi # 0x51933
jmp 0x2bf10
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq *%rax
testl %eax, %eax
je 0x2befb
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x2c0fc(%rip), %rdi # 0x57fe8
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29ffe
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2b587
leaq 0x25a4b(%rip), %rsi # 0x5195b
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1cdad
|
/Tigermouthbear[P]flappytiger/external/glfw/src/egl_context.c
|
destroyContextOSMesa
|
static void destroyContextOSMesa(_GLFWwindow* window)
{
if (window->context.osmesa.handle)
{
OSMesaDestroyContext(window->context.osmesa.handle);
window->context.osmesa.handle = NULL;
}
if (window->context.osmesa.buffer)
{
free(window->context.osmesa.buffer);
window->context.osmesa.width = 0;
window->context.osmesa.height = 0;
}
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x2a0(%rdi), %rdi
testq %rdi, %rdi
je 0x2c6c7
leaq 0x2e35a(%rip), %rax # 0x5aa10
callq *0x21050(%rax)
movq $0x0, 0x2a0(%rbx)
movq 0x2b0(%rbx), %rdi
testq %rdi, %rdi
je 0x2c6e3
callq 0x143c0
movq $0x0, 0x2a8(%rbx)
popq %rbx
retq
|
/Tigermouthbear[P]flappytiger/external/glfw/src/osmesa_context.c
|
main
|
int main(int argC, char* argV[])
{
// Initialize the XML4C2 system
try
{
XMLPlatformUtils::Initialize();
}
catch (const XMLException& toCatch)
{
std::cerr << "Error during initialization! Message:\n"
<< StrX(toCatch.getMessage()) << std::endl;
return 1;
}
SAXParser::ValSchemes valScheme = SAXParser::Val_Auto;
bool doNamespaces = false;
bool doSchema = false;
bool schemaFullChecking = false;
int argInd;
for (argInd = 1; argInd < argC; argInd++)
{
// Break out on first parm not starting with a dash
if (argV[argInd][0] != '-')
{
usage();
XMLPlatformUtils::Terminate();
return 1;
}
// Watch for special case help request
if (!strcmp(argV[argInd], "-?"))
{
usage();
XMLPlatformUtils::Terminate();
return 1;
}
else if (!strncmp(argV[argInd], "-v=", 3)
|| !strncmp(argV[argInd], "-V=", 3))
{
const char* const parm = &argV[argInd][3];
if (!strcmp(parm, "never"))
valScheme = SAXParser::Val_Never;
else if (!strcmp(parm, "auto"))
valScheme = SAXParser::Val_Auto;
else if (!strcmp(parm, "always"))
valScheme = SAXParser::Val_Always;
else
{
std::cerr << "Unknown -v= value: " << parm << std::endl;
return 2;
}
}
else if (!strcmp(argV[argInd], "-n")
|| !strcmp(argV[argInd], "-N"))
{
doNamespaces = true;
}
else if (!strcmp(argV[argInd], "-s")
|| !strcmp(argV[argInd], "-S"))
{
doSchema = true;
}
else if (!strcmp(argV[argInd], "-f")
|| !strcmp(argV[argInd], "-F"))
{
schemaFullChecking = true;
}
else
{
std::cerr << "Unknown option '" << argV[argInd]
<< "', ignoring it\n" << std::endl;
}
}
//
// Create a SAX parser object. Then, according to what we were told on
// the command line, set it to validate or not.
//
SAXParser* parser = new SAXParser;
parser->setValidationScheme(valScheme);
parser->setDoNamespaces(doNamespaces);
parser->setDoSchema(doSchema);
parser->setHandleMultipleImports (true);
parser->setValidationSchemaFullChecking(schemaFullChecking);
//
// Create our SAX handler object and install it on the parser, as the
// document and error handlers.
//
MemParseHandlers handler;
parser->setDocumentHandler(&handler);
parser->setErrorHandler(&handler);
//
// Create MemBufferInputSource from the buffer containing the XML
// statements.
//
// NOTE: We are using strlen() here, since we know that the chars in
// our hard coded buffer are single byte chars!!! The parameter wants
// the number of BYTES, not chars, so when you create a memory buffer
// give it the byte size (which just happens to be the same here.)
//
MemBufInputSource* memBufIS = new MemBufInputSource
(
(const XMLByte*)gXMLInMemBuf
, strlen(gXMLInMemBuf)
, gMemBufId
, false
);
//
// Get the starting time and kick off the parse of the indicated
// file. Catch any exceptions that might propogate out of it.
//
unsigned long duration;
int errorCount = 0;
int errorCode = 0;
try
{
const unsigned long startMillis = XMLPlatformUtils::getCurrentMillis();
parser->parse(*memBufIS);
const unsigned long endMillis = XMLPlatformUtils::getCurrentMillis();
duration = endMillis - startMillis;
errorCount = parser->getErrorCount();
}
catch (const OutOfMemoryException&)
{
std::cerr << "OutOfMemoryException" << std::endl;
errorCode = 5;
}
catch (const XMLException& e)
{
std::cerr << "\nError during parsing memory stream:\n"
<< "Exception message is: \n"
<< StrX(e.getMessage()) << "\n" << std::endl;
errorCode = 4;
}
if(errorCode) {
XMLPlatformUtils::Terminate();
return errorCode;
}
// Print out the stats that we collected and time taken.
if (!errorCount) {
std::cout << "\nFinished parsing the memory buffer containing the following "
<< "XML statements:\n\n"
<< gXMLInMemBuf
<< "\n\n\n"
<< "Parsing took " << duration << " ms ("
<< handler.getElementCount() << " elements, "
<< handler.getAttrCount() << " attributes, "
<< handler.getSpaceCount() << " spaces, "
<< handler.getCharacterCount() << " characters).\n" << std::endl;
}
//
// Delete the parser itself. Must be done prior to calling Terminate, below.
//
delete parser;
delete memBufIS;
// And call the termination method
XMLPlatformUtils::Terminate();
if (errorCount > 0)
return 4;
else
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movl %edi, %ebx
movq 0x4bc6(%rip), %rdi # 0x6fc0
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2180
cmpl $0x2, %ebx
jl 0x25d7
movl %ebx, %r12d
movl $0x2, %ebp
movl $0x1, %r15d
movl $0x0, 0xc(%rsp)
movq 0x4bc5(%rip), %rbx # 0x6ff0
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movq (%r14,%r15,8), %r13
cmpb $0x2d, (%r13)
jne 0x2867
cmpb $0x3f, 0x1(%r13)
jne 0x245c
cmpb $0x0, 0x2(%r13)
je 0x2867
cmpb $0x76, 0x1(%r13)
jne 0x246a
cmpb $0x3d, 0x2(%r13)
je 0x2478
cmpb $0x56, 0x1(%r13)
jne 0x24cb
cmpb $0x3d, 0x2(%r13)
jne 0x24cb
addq $0x3, %r13
movq %r13, %rdi
leaq 0x1da7(%rip), %rsi # 0x422d
callq 0x2150
testl %eax, %eax
je 0x255c
movq %r13, %rdi
leaq 0x1d96(%rip), %rsi # 0x4233
callq 0x2150
testl %eax, %eax
je 0x2568
movq %r13, %rdi
leaq 0x1d84(%rip), %rsi # 0x4238
callq 0x2150
movl $0x1, %ebp
testl %eax, %eax
je 0x25c9
jmp 0x2887
cmpb $0x6e, 0x1(%r13)
jne 0x24d9
cmpb $0x0, 0x2(%r13)
je 0x2554
cmpb $0x4e, 0x1(%r13)
jne 0x24e7
cmpb $0x0, 0x2(%r13)
je 0x2554
cmpb $0x73, 0x1(%r13)
jne 0x24f5
cmpb $0x0, 0x2(%r13)
je 0x2560
cmpb $0x53, 0x1(%r13)
jne 0x2503
cmpb $0x0, 0x2(%r13)
je 0x2560
cmpb $0x66, 0x1(%r13)
jne 0x2511
cmpb $0x0, 0x2(%r13)
je 0x256f
cmpb $0x46, 0x1(%r13)
jne 0x251f
cmpb $0x0, 0x2(%r13)
je 0x256f
movl $0x10, %edx
movq %rbx, %rdi
leaq 0x1d25(%rip), %rsi # 0x4253
callq 0x21d0
movq (%r14,%r15,8), %r13
testq %r13, %r13
je 0x2577
movq %r13, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x258e
movb $0x1, %al
movl %eax, 0xc(%rsp)
jmp 0x25c9
xorl %ebp, %ebp
jmp 0x25c9
movb $0x1, %al
movl %eax, 0x8(%rsp)
jmp 0x25c9
movl $0x2, %ebp
jmp 0x25c9
movb $0x1, %al
movl %eax, 0x4(%rsp)
jmp 0x25c9
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2220
movl $0xf, %edx
movq %rbx, %rdi
leaq 0x1cc7(%rip), %rsi # 0x4264
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2090
incq %r15
cmpq %r15, %r12
jne 0x243b
jmp 0x25f4
movl $0x2, %ebp
movl $0x0, 0x4(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x108, %edi # imm = 0x108
callq 0x2130
movq %rax, %rbx
movq 0x49d8(%rip), %r13 # 0x6fe0
movq (%r13), %rdx
movq %rax, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x21c0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2100
movzbl 0xc(%rsp), %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x2070
movzbl 0x8(%rsp), %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x2140
movq %rbx, %rdi
movl $0x1, %esi
callq 0x21a0
movzbl 0x4(%rsp), %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x20c0
leaq 0x18(%rsp), %rdi
callq 0x2b34
leaq 0x28(%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
leaq 0x30(%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movl $0x48, %edi
callq 0x2130
movq %rax, %r14
movq (%r13), %r9
leaq 0x1cc6(%rip), %rsi # 0x4363
leaq 0x1e92(%rip), %rcx # 0x4536
movl $0x1d2, %edx # imm = 0x1D2
movq %rax, %rdi
xorl %r8d, %r8d
callq 0x2200
callq 0x2190
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x30(%rax)
callq 0x2190
movq %rax, %r12
movq %rbx, %rdi
callq 0x2160
movl %eax, %ebp
testl %eax, %eax
jne 0x283a
movq 0x48e7(%rip), %rdi # 0x6fd0
leaq 0x1bd8(%rip), %rsi # 0x42c8
movl $0x3d, %edx
callq 0x21d0
movq 0x48cf(%rip), %rdi # 0x6fd0
leaq 0x1bfe(%rip), %rsi # 0x4306
movl $0x11, %edx
callq 0x21d0
movq 0x48b7(%rip), %rdi # 0x6fd0
leaq 0x1c43(%rip), %rsi # 0x4363
movl $0x1d2, %edx # imm = 0x1D2
callq 0x21d0
movq 0x489f(%rip), %rdi # 0x6fd0
leaq 0x1be0(%rip), %rsi # 0x4318
movl $0x3, %edx
callq 0x21d0
movq 0x4887(%rip), %rdi # 0x6fd0
leaq 0x1bcc(%rip), %rsi # 0x431c
movl $0xd, %edx
callq 0x21d0
subq %r15, %r12
movq 0x486c(%rip), %rdi # 0x6fd0
movq %r12, %rsi
callq 0x20a0
movq %rax, %r15
leaq 0x1bb4(%rip), %rsi # 0x432a
movl $0x5, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x20a0
movq %rax, %r15
leaq 0x1b96(%rip), %rsi # 0x4330
movl $0xb, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x20a0
movq %rax, %r15
leaq 0x1b7e(%rip), %rsi # 0x433c
movl $0xd, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x50(%rsp), %rsi
movq %r15, %rdi
callq 0x20a0
movq %rax, %r15
leaq 0x1b68(%rip), %rsi # 0x434a
movl $0x9, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x20a0
movq %rax, %r15
leaq 0x1b4e(%rip), %rsi # 0x4354
movl $0xe, %edx
movq %rax, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r15, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2090
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
callq 0x20b0
xorl %ebx, %ebx
testl %ebp, %ebp
setg %bl
shll $0x2, %ebx
leaq 0x18(%rsp), %rdi
callq 0x2b6c
jmp 0x2876
callq 0x239c
callq 0x20b0
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19b1(%rip), %rsi # 0x423f
movl $0x13, %edx
movq %rbx, %rdi
callq 0x21d0
movq %r13, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2090
movl $0x2, %ebx
jmp 0x2876
movq %rax, %r15
movq %r14, %rdi
callq 0x2060
jmp 0x2ab1
jmp 0x2aae
movq %rax, %r15
movq %rbx, %rdi
callq 0x2060
jmp 0x2abb
movq %rax, %r15
cmpl $0x1, %edx
jne 0x2abb
movq %r15, %rdi
callq 0x2030
movq %rax, %rbx
movq 0x46ce(%rip), %rdi # 0x6ff0
leaq 0x18dd(%rip), %rsi # 0x4206
movl $0x26, %edx
callq 0x21d0
movq 0x20(%rbx), %rdi
movq 0x46a2(%rip), %rax # 0x6fe0
movq (%rax), %rsi
callq 0x20e0
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq 0x469b(%rip), %rdi # 0x6ff0
callq 0x2ac3
movq %rax, %rdi
callq 0x21e0
leaq 0x18(%rsp), %rdi
callq 0x2b0c
callq 0x2120
jmp 0x2871
jmp 0x2978
movq %rax, %r15
jmp 0x298a
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x2b0c
callq 0x2120
jmp 0x2abb
jmp 0x2996
movq %rax, %r15
cmpl $0x2, %edx
jne 0x29d9
movq %r15, %rdi
callq 0x2030
movq 0x4643(%rip), %rdi # 0x6ff0
leaq 0x18ff(%rip), %rsi # 0x42b3
movl $0x14, %edx
callq 0x21d0
movq 0x462b(%rip), %rdi # 0x6ff0
callq 0x21e0
movl $0x5, %ebx
callq 0x2120
jmp 0x2a71
cmpl $0x1, %edx
jne 0x2ab1
movq %r15, %rdi
callq 0x2030
movq %rax, %rbx
movq 0x45fc(%rip), %rdi # 0x6ff0
leaq 0x1879(%rip), %rsi # 0x4274
movl $0x25, %edx
callq 0x21d0
movq 0x45e4(%rip), %rdi # 0x6ff0
leaq 0x1887(%rip), %rsi # 0x429a
movl $0x18, %edx
callq 0x21d0
movq 0x20(%rbx), %rdi
movq (%r13), %rsi
callq 0x20e0
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x45b7(%rip), %rdi # 0x6ff0
callq 0x2ac3
movq %rax, %rbx
leaq 0x18d2(%rip), %rsi # 0x431a
movl $0x1, %edx
movq %rax, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x21e0
leaq 0x10(%rsp), %rdi
callq 0x2b0c
movl $0x4, %ebx
callq 0x2120
callq 0x20b0
jmp 0x285b
jmp 0x2aae
jmp 0x2a81
jmp 0x2aae
movq %rax, %r15
jmp 0x2a9d
movq %rax, %r15
callq 0x2120
jmp 0x2ab1
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x2b0c
callq 0x2120
jmp 0x2ab1
movq %rax, %rdi
callq 0x2b26
jmp 0x2aae
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x2b6c
movq %r15, %rdi
callq 0x20f0
|
/apache[P]xerces-c/samples/src/MemParse/MemParse.cpp
|
operator<<(std::ostream&, StrX const&)
|
inline std::ostream& operator<<(std::ostream& target, const StrX& toDump)
{
target << toDump.localForm();
return target;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x2aea
movq %r14, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x2b01
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/apache[P]xerces-c/samples/src/MemParse/MemParse.hpp
|
MemParseHandlers::error(xercesc_4_0::SAXParseException const&)
|
void MemParseHandlers::error(const SAXParseException& e)
{
std::cerr << "\nError at (file " << StrX(e.getSystemId())
<< ", line " << e.getLineNumber()
<< ", char " << e.getColumnNumber()
<< "): " << StrX(e.getMessage()) << std::endl;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x43d3(%rip), %r14 # 0x6ff0
leaq 0x1959(%rip), %rsi # 0x457d
movl $0x10, %edx
movq %r14, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2110
movq 0x43a0(%rip), %r12 # 0x6fe0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x20e0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2c75
movq %rax, %r15
movq %rax, %rdi
callq 0x2080
movq 0x4388(%rip), %rdi # 0x6ff0
movq %r15, %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x2c8d
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq 0x435c(%rip), %rdi # 0x6ff0
leaq 0x18f3(%rip), %rsi # 0x458e
movl $0x7, %edx
callq 0x21d0
movq %rbx, %rdi
callq 0x2040
movq 0x433c(%rip), %rdi # 0x6ff0
movq %rax, %rsi
callq 0x20a0
movq %rax, %r14
leaq 0x18d0(%rip), %rsi # 0x4596
movl $0x7, %edx
movq %rax, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
movq %rax, %rsi
callq 0x20a0
movq %rax, %r14
leaq 0x18ae(%rip), %rsi # 0x459e
movl $0x3, %edx
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r12), %rsi
movq %rax, %rdi
callq 0x20e0
movq %rax, %rbx
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2d37
movq %rbx, %rdi
callq 0x2080
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x2d51
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x2b0c
leaq 0x10(%rsp), %rdi
callq 0x2b0c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2da9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2b0c
jmp 0x2dac
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2b0c
movq %rbx, %rdi
callq 0x20f0
|
/apache[P]xerces-c/samples/src/MemParse/MemParseHandlers.cpp
|
MemParseHandlers::warning(xercesc_4_0::SAXParseException const&)
|
void MemParseHandlers::warning(const SAXParseException& e)
{
std::cerr << "\nWarning at (file " << StrX(e.getSystemId())
<< ", line " << e.getLineNumber()
<< ", char " << e.getColumnNumber()
<< "): " << StrX(e.getMessage()) << std::endl;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x405b(%rip), %r14 # 0x6ff0
leaq 0x161d(%rip), %rsi # 0x45b9
movl $0x12, %edx
movq %r14, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2110
movq 0x4028(%rip), %r12 # 0x6fe0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x20e0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2fed
movq %rax, %r15
movq %rax, %rdi
callq 0x2080
movq 0x4010(%rip), %rdi # 0x6ff0
movq %r15, %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x3005
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq 0x3fe4(%rip), %rdi # 0x6ff0
leaq 0x157b(%rip), %rsi # 0x458e
movl $0x7, %edx
callq 0x21d0
movq %rbx, %rdi
callq 0x2040
movq 0x3fc4(%rip), %rdi # 0x6ff0
movq %rax, %rsi
callq 0x20a0
movq %rax, %r14
leaq 0x1558(%rip), %rsi # 0x4596
movl $0x7, %edx
movq %rax, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x21b0
movq %r14, %rdi
movq %rax, %rsi
callq 0x20a0
movq %rax, %r14
leaq 0x1536(%rip), %rsi # 0x459e
movl $0x3, %edx
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r12), %rsi
movq %rax, %rdi
callq 0x20e0
movq %rax, %rbx
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x30af
movq %rbx, %rdi
callq 0x2080
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21d0
jmp 0x30c9
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2220
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x2b0c
leaq 0x10(%rsp), %rdi
callq 0x2b0c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3121
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2b0c
jmp 0x3124
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2b0c
movq %rbx, %rdi
callq 0x20f0
|
/apache[P]xerces-c/samples/src/MemParse/MemParseHandlers.cpp
|
nsync::nsync_time_sleep(timespec)
|
nsync_time nsync_time_sleep (nsync_time delay) {
nsync_time start = nsync_time_now ();
nsync_time expected_end = nsync_time_add (start, delay);
nsync_time remain;
std::chrono::nanoseconds delay_ns(NSYNC_TIME_NSEC (delay) +
NSYNC_NS_IN_S_ * (int64_t) NSYNC_TIME_SEC (delay));
std::this_thread::sleep_for (delay_ns);
nsync_time actual_end = nsync_time_now ();
if (nsync_time_cmp (actual_end, expected_end) < 0) {
remain = nsync_time_sub (expected_end, actual_end);
} else {
remain = nsync_time_zero;
}
return (remain);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
callq 0xc8e0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0xca90
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x18(%rbp), %rax
imulq $0x3b9aca00, -0x20(%rbp), %rcx # imm = 0x3B9ACA00
addq %rcx, %rax
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xcc80
leaq -0x68(%rbp), %rdi
callq 0xccf0
callq 0xc8e0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x98(%rbp), %rcx
callq 0xcb00
cmpl $0x0, %eax
jge 0xca68
movq -0x40(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq -0xc8(%rbp), %rcx
callq 0xcb70
movq %rax, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xca7e
leaq 0x2bf9(%rip), %rax # 0xf668
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xd0, %rsp
popq %rbp
retq
nop
|
/google[P]nsync/build_O0/cpp/platform/c++11/src/time_rep_timespec.cc
|
Omega_h::find_unique(Omega_h::Read<int>, Omega_h_Family, int, int)
|
LOs find_unique(LOs const hv2v, Omega_h_Family const family, Int const high_dim,
Int const low_dim) {
OMEGA_H_TIME_FUNCTION;
OMEGA_H_CHECK(high_dim > low_dim);
OMEGA_H_CHECK(low_dim <= 2);
OMEGA_H_CHECK(hv2v.size() % element_degree(family, high_dim, VERT) == 0);
auto const uv2v = form_uses(hv2v, family, high_dim, low_dim);
auto const deg = element_degree(family, low_dim, VERT);
return find_unique_deg(deg, uv2v);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x171952(%rip), %rsi # 0x277797
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xef870
leaq 0x17143a(%rip), %rdx # 0x277295
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xed920
leaq 0x50(%rsp), %rdi
movl $0x92, %esi
callq 0xf9ed0
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xf4ff0
movq 0x90(%rsp), %rsi
leaq 0x1719b4(%rip), %rdi # 0x277853
callq 0xf9c20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x10(%rsp), %rdi
callq 0xf00f0
cmpl %r14d, %r15d
jle 0x1062e3
cmpl $0x2, %r14d
jg 0x1062f1
movq (%r12), %rax
testb $0x1, %al
jne 0x105eef
movq (%rax), %rax
jmp 0x105ef3
shrq $0x3, %rax
shrq $0x2, %rax
testl %ebp, %ebp
je 0x105f10
cmpl $0x3, %r15d
ja 0x105f20
movl %r15d, %ecx
leaq 0x171865(%rip), %rdx # 0x277770
movl (%rdx,%rcx,4), %ecx
jmp 0x105f23
leal 0x1(%r15), %edx
cmpl $0x4, %r15d
pushq $-0x1
popq %rcx
cmovbl %edx, %ecx
jmp 0x105f23
pushq $-0x1
popq %rcx
cltd
idivl %ecx
testl %edx, %edx
jne 0x1062ff
leaq 0xc0(%rsp), %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0xd0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movl %ebp, %edx
movl %r15d, %ecx
movl %r14d, %r8d
callq 0xff8d0
leaq 0xc0(%rsp), %rdi
callq 0xff620
testl %ebp, %ebp
je 0x105f81
cmpl $0x2, %r14d
ja 0x105f91
movl %r14d, %eax
leaq 0x171790(%rip), %rcx # 0x27770c
movl (%rcx,%rax,4), %ebp
jmp 0x105f94
leal 0x1(%r14), %eax
cmpl $0x3, %r14d
pushq $-0x1
popq %rbp
cmovbl %eax, %ebp
jmp 0x105f94
pushq $-0x1
popq %rbp
leaq 0x30(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xf0580
leaq 0x1717ea(%rip), %rsi # 0x277797
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xef870
leaq 0x1712d2(%rip), %rdx # 0x277295
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xed920
leaq 0x50(%rsp), %rdi
movl $0x86, %esi
callq 0xf9ed0
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xf4ff0
movq 0x90(%rsp), %rsi
leaq 0x1719f8(%rip), %rdi # 0x2779ff
callq 0xf9c20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf0580
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movl %ebp, %esi
callq 0xf67f0
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf0580
leaq 0x40(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xf8e10
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x40(%rsp), %rcx
movl %ebp, %esi
callq 0xf7e80
leaq 0x40(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x190(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf0580
leaq 0xb0(%rsp), %rdi
leaq 0x190(%rsp), %rsi
movl %ebp, %edx
callq 0x101340
leaq 0x190(%rsp), %rdi
callq 0xff620
leaq 0x170(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf0580
leaq 0x160(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xf0580
leaq 0x180(%rsp), %rdi
leaq 0x170(%rsp), %rdx
leaq 0x160(%rsp), %rcx
movl %ebp, %esi
callq 0xfb440
leaq 0x160(%rsp), %rdi
callq 0xff620
leaq 0x170(%rsp), %rdi
callq 0xff620
leaq 0x140(%rsp), %rdi
leaq 0x180(%rsp), %rsi
callq 0xf8e10
leaq 0x150(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0xff640
leaq 0x140(%rsp), %rdi
callq 0xf9e00
leaq 0x120(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0xf0580
leaq 0x110(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0xf0580
leaq 0x130(%rsp), %rdi
leaq 0x120(%rsp), %rsi
leaq 0x110(%rsp), %rdx
callq 0xfd2f0
leaq 0x110(%rsp), %rdi
callq 0xff620
leaq 0x120(%rsp), %rdi
callq 0xff620
leaq 0xf0(%rsp), %rdi
leaq 0x130(%rsp), %rsi
callq 0xf0580
leaq 0xe0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf0580
leaq 0x100(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
movl %ebp, %ecx
callq 0xf17d0
leaq 0x100(%rsp), %rsi
movq %rbx, %rdi
callq 0xf7a10
leaq 0x100(%rsp), %rdi
callq 0xff620
leaq 0xe0(%rsp), %rdi
callq 0xff620
leaq 0xf0(%rsp), %rdi
callq 0xff620
leaq 0x130(%rsp), %rdi
callq 0xff620
leaq 0x150(%rsp), %rdi
callq 0xff620
leaq 0x180(%rsp), %rdi
callq 0xf9e00
leaq 0xb0(%rsp), %rdi
callq 0xff620
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0x90(%rsp), %rdi
callq 0xf9e00
leaq 0xf(%rsp), %rdi
callq 0xf7d50
leaq 0x30(%rsp), %rdi
callq 0xff620
leaq 0xd0(%rsp), %rdi
callq 0xff620
leaq 0xe(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x93, %ecx
leaq 0x171570(%rip), %rsi # 0x27785f
jmp 0x10630b
movl $0x94, %ecx
leaq 0x171575(%rip), %rsi # 0x277872
jmp 0x10630b
movl $0x95, %ecx
leaq 0x171574(%rip), %rsi # 0x27787f
leaq 0x170d76(%rip), %rdi # 0x277088
leaq 0x17147e(%rip), %rdx # 0x277797
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0xff620
jmp 0x106335
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0xff620
jmp 0x106347
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xff620
jmp 0x106359
movq %rax, %rbx
leaq 0x130(%rsp), %rdi
jmp 0x106380
movq %rax, %rbx
leaq 0x110(%rsp), %rdi
callq 0xff620
jmp 0x106378
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0xff620
leaq 0x150(%rsp), %rdi
callq 0xff620
leaq 0x180(%rsp), %rdi
callq 0xf9e00
leaq 0xb0(%rsp), %rdi
callq 0xff620
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0x90(%rsp), %rdi
callq 0xf9e00
leaq 0xf(%rsp), %rdi
callq 0xf7d50
leaq 0x30(%rsp), %rdi
callq 0xff620
leaq 0xd0(%rsp), %rdi
callq 0xff620
leaq 0xe(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rdi
callq 0xff4a0
movq %rax, %rbx
jmp 0x106385
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
callq 0xf9e00
jmp 0x106392
movq %rax, %rbx
jmp 0x106392
movq %rax, %rbx
leaq 0x160(%rsp), %rdi
callq 0xff620
jmp 0x106427
movq %rax, %rbx
leaq 0x170(%rsp), %rdi
callq 0xff620
jmp 0x10639f
movq %rax, %rbx
jmp 0x10639f
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
jmp 0x1063a7
movq %rax, %rbx
jmp 0x1063ac
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x10646b
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x1063b1
movq %rax, %rbx
jmp 0x1063b6
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xff620
jmp 0x1063c3
movq %rax, %rbx
jmp 0x1063c3
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x1064ac
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x1064bb
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x1064ca
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x1063cd
movq %rax, %rbx
jmp 0x1063cd
movq %rax, %rbx
jmp 0x1063d7
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
jmp 0x1063df
jmp 0x106545
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x106510
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x10651f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x10652e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x1063ee
movq %rax, %rbx
jmp 0x1063ee
movq %rax, %rbx
jmp 0x1063e4
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::sort_by_high_index(Omega_h::Read<int>, Omega_h::Write<int>, Omega_h::Write<signed char>)
|
void sort_by_high_index(
LOs const l2lh, Write<LO> const lh2h, Write<I8> const codes) {
OMEGA_H_TIME_FUNCTION;
LO const nl = l2lh.size() - 1;
auto f = OMEGA_H_LAMBDA(LO const l) {
LO const begin = l2lh[l];
LO const end = l2lh[l + 1];
for (LO j = begin; j < end; ++j) {
LO k_min = j;
GO min_h = lh2h[j];
for (LO k = j + 1; k < end; ++k) {
GO const h = lh2h[k];
if (h < min_h) {
k_min = k;
min_h = h;
}
}
swap2(lh2h[j], lh2h[k_min]);
swap2(codes[j], codes[k_min]);
}
};
parallel_for(nl, std::move(f));
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x170827(%rip), %rsi # 0x277797
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0xef870
leaq 0x17030c(%rip), %rdx # 0x277295
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xed920
leaq 0x40(%rsp), %rdi
movl $0xb4, %esi
callq 0xf9ed0
leaq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xf4ff0
movq 0x10(%rsp), %rsi
leaq 0x1708f6(%rip), %rdi # 0x2778c3
callq 0xf9c20
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x40(%rsp), %rdi
callq 0xf00f0
leaq 0x80(%rsp), %rdi
callq 0xf00f0
leaq 0x60(%rsp), %rdi
callq 0xf00f0
movq (%r14), %r12
testb $0x1, %r12b
jne 0x10700c
movq (%r12), %r12
jmp 0x107010
shrq $0x3, %r12
leaq 0x80(%rsp), %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf0580
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x1709fe(%rip), %rsi # 0x277a4b
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x170232(%rip), %rdx # 0x277295
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xed920
leaq 0xb0(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9ed0
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0xf4ff0
movq 0x10(%rsp), %rsi
leaq 0x170999(%rip), %rdi # 0x277a3e
callq 0xf9c20
shrq $0x2, %r12
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0xb0(%rsp), %rdi
callq 0xf00f0
leaq 0x60(%rsp), %rdi
callq 0xf00f0
leaq 0x40(%rsp), %rdi
callq 0xf00f0
cmpl $0x2, %r12d
jl 0x1071ae
movq 0x20abd6(%rip), %r13 # 0x311cc0
movb $0x1, (%r13)
leaq 0x10(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xf0580
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8e10
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq %rax, %r12
movb $0x0, (%r13)
movl %r12d, %eax
xorl %ecx, %ecx
cmpq %rax, %rcx
je 0x1071a4
movq 0x18(%rsp), %rdx
movslq (%rdx,%rcx,4), %rsi
movslq 0x4(%rdx,%rcx,4), %rdx
cmpq %rdx, %rsi
jge 0x10719f
leaq 0x1(%rsi), %rdi
movslq %edi, %r10
movq 0x28(%rsp), %r8
movl (%r8,%rsi,4), %r9d
movslq %r9d, %r11
movl %esi, %ebx
cmpq %rdx, %r10
jge 0x107176
movslq (%r8,%r10,4), %r14
cmpq %r14, %r11
cmovgl %r10d, %ebx
cmovgeq %r14, %r11
incq %r10
jmp 0x10715d
movslq %ebx, %r10
movl (%r8,%r10,4), %r11d
movl %r11d, (%r8,%rsi,4)
movl %r9d, (%r8,%r10,4)
movq 0x38(%rsp), %r8
movb (%r8,%rsi), %r9b
movb (%r8,%r10), %r11b
movb %r11b, (%r8,%rsi)
movb %r9b, (%r8,%r10)
movq %rdi, %rsi
jmp 0x107143
incq %rcx
jmp 0x107130
leaq 0x10(%rsp), %rdi
callq 0x1072d4
leaq 0xe(%rsp), %rdi
callq 0xf7d50
leaq 0x80(%rsp), %rdi
callq 0x1072d4
leaq 0xd(%rsp), %rdi
callq 0xf7d50
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xff620
jmp 0x1071f0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xff620
jmp 0x1071ff
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0xf7d50
jmp 0x10724d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x10721d
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xf00f0
jmp 0x10722f
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xf00f0
jmp 0x10723e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf00f0
jmp 0x10724d
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x1072d4
jmp 0x10727e
movq %rax, %rbx
movq %r14, %rdi
callq 0xff620
jmp 0x10726c
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xff620
jmp 0x10727e
movq %rax, %rbx
leaq 0xd(%rsp), %rdi
callq 0xf7d50
jmp 0x1072cc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x10729c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf00f0
jmp 0x1072ab
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0xf00f0
jmp 0x1072bd
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xf00f0
jmp 0x1072cc
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::separate_upward_with_codes(int, Omega_h::Read<int>, int, Omega_h::Write<int>, Omega_h::Read<signed char>, Omega_h::Write<signed char>)
|
void separate_upward_with_codes(LO const nlh, LOs const lh2hl,
Int const nlows_per_high, Write<LO> const lh2h, Bytes const down_codes,
Write<Byte> const codes) {
OMEGA_H_TIME_FUNCTION;
auto f = OMEGA_H_LAMBDA(LO lh) {
LO const hl = lh2hl[lh];
LO const h = hl / nlows_per_high;
lh2h[lh] = h;
Int const which_down = hl % nlows_per_high;
auto const down_code = down_codes[hl];
bool const is_flipped = code_is_flipped(down_code);
Int const rotation = code_rotation(down_code);
codes[lh] = make_code(is_flipped, rotation, which_down);
};
parallel_for(nlh, std::move(f));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %ebx
leaq 0x17047c(%rip), %rsi # 0x277797
leaq 0x70(%rsp), %rdi
leaq 0xd8(%rsp), %rdx
callq 0xef870
leaq 0x16ff61(%rip), %rdx # 0x277295
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xed920
leaq 0x50(%rsp), %rdi
movl $0xcd, %esi
callq 0xf9ed0
leaq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xf4ff0
movq 0x8(%rsp), %rsi
leaq 0x17055e(%rip), %rdi # 0x2778d6
callq 0xf9c20
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0xa8(%rsp), %r14
movl %ebp, -0x8(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0xb8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xf8e10
leaq 0x17064f(%rip), %rsi # 0x277a4b
leaq 0x50(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x16fe83(%rip), %rdx # 0x277295
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xed920
leaq 0xd8(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9ed0
leaq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xd8(%rsp), %rdx
callq 0xf4ff0
movq 0x8(%rsp), %rsi
leaq 0x1705ea(%rip), %rdi # 0x277a3e
callq 0xf9c20
leaq 0x8(%rsp), %rdi
callq 0xf00f0
leaq 0xd8(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
testl %ebx, %ebx
jle 0x107535
movq 0x20a82d(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xf0580
movl 0xa0(%rsp), %eax
leaq 0x20(%rsp), %r13
movl %eax, -0x8(%r13)
movq %r13, %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0xf8e10
movb $0x0, (%rbp)
movl %ebx, %esi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x10752b
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %r8
movslq (%rax,%rdi,4), %rcx
movl %ecx, %eax
cltd
idivl 0x18(%rsp)
movl %eax, (%r8,%rdi,4)
movl %ecx, %eax
cltd
idivl 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %r8
movb (%rax,%rcx), %al
shlb $0x3, %dl
andb $0x7, %al
orb %dl, %al
movb %al, (%r8,%rdi)
incq %rdi
jmp 0x1074e9
leaq 0x8(%rsp), %rdi
callq 0x107676
leaq 0x6(%rsp), %rdi
callq 0xf7d50
leaq 0x90(%rsp), %rdi
callq 0x107676
leaq 0x5(%rsp), %rdi
callq 0xf7d50
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xf9e00
jmp 0x107578
movq %rax, %rbx
movq %r13, %rdi
callq 0xff620
jmp 0x107585
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xff620
jmp 0x107594
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0xf7d50
jmp 0x1075e2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x1075b2
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0xf00f0
jmp 0x1075c4
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x1075d3
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x1075e2
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x107676
jmp 0x107620
movq %rax, %rbx
movq %r15, %rdi
callq 0xf9e00
jmp 0x107601
movq %rax, %rbx
movq %r14, %rdi
callq 0xff620
jmp 0x10760e
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xff620
jmp 0x107620
movq %rax, %rbx
leaq 0x5(%rsp), %rdi
callq 0xf7d50
jmp 0x10766e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf00f0
jmp 0x10763e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x10764d
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10765f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x10766e
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::filter_parents(Omega_h::Parents, int)
|
Bytes filter_parents(Parents const c2p, Int const parent_dim) {
OMEGA_H_TIME_FUNCTION;
Write<Byte> filter(c2p.parent_idx.size());
auto f = OMEGA_H_LAMBDA(LO c) {
auto const code = c2p.codes[c];
if (amr::code_parent_dim(code) == parent_dim)
filter[c] = 1;
else
filter[c] = 0;
};
parallel_for(c2p.parent_idx.size(), std::move(f));
return filter;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16f416(%rip), %rsi # 0x277797
leaq 0x88(%rsp), %rdi
leaq 0xe0(%rsp), %rdx
callq 0xef870
leaq 0x16eef8(%rip), %rdx # 0x277295
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xed920
leaq 0x68(%rsp), %rdi
movl $0x10a, %esi # imm = 0x10A
callq 0xf9ed0
leaq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0xf4ff0
movq 0x10(%rsp), %rsi
leaq 0x16f51f(%rip), %rdi # 0x277903
callq 0xf9c20
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x68(%rsp), %rdi
callq 0xf00f0
leaq 0xa8(%rsp), %rdi
callq 0xf00f0
leaq 0x88(%rsp), %rdi
callq 0xf00f0
movq (%r14), %r15
testb $0x1, %r15b
jne 0x108425
movq (%r15), %r15
jmp 0x108429
shrq $0x3, %r15
leaq 0x175087(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rdx
callq 0xef870
shrq $0x2, %r15
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl %r15d, %esi
callq 0xf0f30
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0xa8(%rsp), %rdi
movq %r14, %rsi
callq 0xee5d0
leaq 0xd0(%rsp), %r15
movl %ebp, -0x8(%r15)
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0xf8e10
movq (%r14), %r14
testb $0x1, %r14b
jne 0x108499
movq (%r14), %r14
jmp 0x10849d
shrq $0x3, %r14
leaq 0x16f5a7(%rip), %rsi # 0x277a4b
leaq 0x68(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x16eddb(%rip), %rdx # 0x277295
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xed920
leaq 0xe0(%rsp), %rdi
pushq $0x54
popq %rsi
callq 0xf9ed0
leaq 0x10(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
callq 0xf4ff0
movq 0x10(%rsp), %rsi
leaq 0x16f53c(%rip), %rdi # 0x277a3e
callq 0xf9c20
shrq $0x2, %r14
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0xe0(%rsp), %rdi
callq 0xf00f0
leaq 0x88(%rsp), %rdi
callq 0xf00f0
leaq 0x68(%rsp), %rdi
callq 0xf00f0
testl %r14d, %r14d
jle 0x1085ae
movq 0x20977b(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
leaq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xee5d0
movl 0xc8(%rsp), %eax
leaq 0x38(%rsp), %rdi
movl %eax, -0x8(%rdi)
movq %r15, %rsi
callq 0x100b80
movb $0x0, (%r12)
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpq %rax, %r14
je 0x1085a4
movq 0x28(%rsp), %rcx
movzbl (%rcx,%rax), %ecx
andl $0x3, %ecx
cmpl %ecx, 0x30(%rsp)
movq 0x40(%rsp), %rcx
sete (%rcx,%rax)
incq %rax
jmp 0x108581
leaq 0x10(%rsp), %rdi
callq 0x108722
leaq 0xe(%rsp), %rdi
callq 0xf7d50
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x100b80
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x58(%rsp), %rdi
callq 0xf9e00
leaq 0xa8(%rsp), %rdi
callq 0x108722
leaq 0x48(%rsp), %rdi
callq 0xf9e00
leaq 0xd(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0x100, %rsp # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf0190
jmp 0x108624
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0xf7d50
jmp 0x108686
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf9e00
jmp 0x108686
jmp 0x108683
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x108653
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0xf00f0
jmp 0x108665
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf00f0
jmp 0x108677
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf00f0
jmp 0x108686
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x108722
leaq 0x48(%rsp), %rdi
callq 0xf9e00
leaq 0xd(%rsp), %rdi
callq 0xf7d50
jmp 0x108719
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xf0190
jmp 0x108693
movq %rax, %rbx
jmp 0x108693
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x10869d
movq %rax, %rbx
jmp 0x10869d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x1086e6
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf00f0
jmp 0x1086f5
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xf00f0
jmp 0x108707
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf00f0
jmp 0x108719
movq %rax, %rbx
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical<int>(int, Omega_h::Read<int>)
|
Read<I8> get_codes_to_canonical(Int const deg, Read<T> const ev2v) {
OMEGA_H_TIME_FUNCTION;
if (deg == 4) return get_codes_to_canonical_deg<4>(ev2v);
if (deg == 3) return get_codes_to_canonical_deg<3>(ev2v);
if (deg == 2) return get_codes_to_canonical_deg<2>(ev2v);
OMEGA_H_NORETURN(Read<I8>());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x16b57d(%rip), %rsi # 0x277797
leaq 0x58(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x16b065(%rip), %rdx # 0x277295
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xed920
leaq 0x38(%rsp), %rdi
pushq $0x63
popq %rsi
callq 0xf9ed0
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xf4ff0
movq 0x98(%rsp), %rsi
leaq 0x16b50e(%rip), %rdi # 0x277780
callq 0xf9c20
leaq 0x98(%rsp), %rdi
callq 0xf00f0
leaq 0x38(%rsp), %rdi
callq 0xf00f0
leaq 0x78(%rsp), %rdi
callq 0xf00f0
leaq 0x58(%rsp), %rdi
callq 0xf00f0
cmpl $0x2, %ebp
je 0x10c2eb
cmpl $0x3, %ebp
je 0x10c2ce
cmpl $0x4, %ebp
jne 0x10c329
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf0580
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf0e10
jmp 0x10c306
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf0580
movq %rbx, %rdi
movq %r15, %rsi
callq 0x100e20
jmp 0x10c306
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf0580
movq %rbx, %rdi
movq %r15, %rsi
callq 0xee8b0
movq %r15, %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16ad58(%rip), %rdi # 0x277088
leaq 0x16b4be(%rip), %rsi # 0x2777f5
leaq 0x16b459(%rip), %rdx # 0x277797
pushq $0x67
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x10c364
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x10c364
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xff620
jmp 0x10c3b2
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xf00f0
jmp 0x10c380
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf00f0
jmp 0x10c38f
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xf00f0
jmp 0x10c39e
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf00f0
jmp 0x10c3bc
movq %rax, %rbx
jmp 0x10c3bc
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical_deg<3, int>(Omega_h::Read<int>)
|
Read<I8> get_codes_to_canonical_deg(Read<T> const ev2v) {
auto const nev = ev2v.size();
auto const ne = divide_no_remainder(nev, deg);
Write<I8> codes(ne);
auto f = OMEGA_H_LAMBDA(LO e) {
auto const begin = e * deg;
/* find the smallest vertex */
Int min_j = 0;
auto min_v = ev2v[begin];
for (Int j = 1; j < deg; ++j) {
auto const ev = j + begin;
auto const v = ev2v[ev];
if (v < min_v) {
min_j = j;
min_v = v;
}
}
/* rotate to make it first */
auto const rotation = rotation_to_first(deg, min_j);
T tmp[deg];
rotate_adj<deg>(rotation, ev2v, begin, tmp, 0);
auto const is_flipped = IsFlipped<deg>::is(tmp);
codes[e] = make_code(is_flipped, rotation, 0);
};
parallel_for(ne, std::move(f));
return codes;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x10c503
movq (%rdi), %rdi
jmp 0x10c507
shrq $0x3, %rdi
shrq $0x2, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x170f9b(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl %ebp, %esi
callq 0xf0f30
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf8e10
leaq 0x10(%rsp), %rsi
movl %ebp, %edi
callq 0xefd90
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x100b80
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x40(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xfdc10
leaq 0x30(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x10c5ee
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xff620
jmp 0x10c5f8
movq %rax, %rbx
jmp 0x10c5f8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x10c602
movq %rax, %rbx
jmp 0x10c602
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfdc10
leaq 0x30(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical_deg<2, int>(Omega_h::Read<int>)
|
Read<I8> get_codes_to_canonical_deg(Read<T> const ev2v) {
auto const nev = ev2v.size();
auto const ne = divide_no_remainder(nev, deg);
Write<I8> codes(ne);
auto f = OMEGA_H_LAMBDA(LO e) {
auto const begin = e * deg;
/* find the smallest vertex */
Int min_j = 0;
auto min_v = ev2v[begin];
for (Int j = 1; j < deg; ++j) {
auto const ev = j + begin;
auto const v = ev2v[ev];
if (v < min_v) {
min_j = j;
min_v = v;
}
}
/* rotate to make it first */
auto const rotation = rotation_to_first(deg, min_j);
T tmp[deg];
rotate_adj<deg>(rotation, ev2v, begin, tmp, 0);
auto const is_flipped = IsFlipped<deg>::is(tmp);
codes[e] = make_code(is_flipped, rotation, 0);
};
parallel_for(ne, std::move(f));
return codes;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x10c626
movq (%rdi), %rdi
jmp 0x10c62a
shrq $0x3, %rdi
shrq $0x2, %rdi
pushq $0x2
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x170e78(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl %ebp, %esi
callq 0xf0f30
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf0580
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf8e10
leaq 0x10(%rsp), %rsi
movl %ebp, %edi
callq 0xf3af0
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x100b80
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x40(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xf8de0
leaq 0x30(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x10c711
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xff620
jmp 0x10c71b
movq %rax, %rbx
jmp 0x10c71b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x10c725
movq %rax, %rbx
jmp 0x10c725
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf8de0
leaq 0x30(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
void Omega_h::find_matches_deg<2, int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Adj, Omega_h::Write<int>*, Omega_h::Write<signed char>*, bool)
|
void find_matches_deg(LOs const a2fv, Read<T> const av2v,
Read<T> const bv2v, Adj const v2b, Write<LO>* a2b_out, Write<I8>* codes_out,
bool const allow_duplicates) {
OMEGA_H_TIME_FUNCTION;
LO const na = a2fv.size();
OMEGA_H_CHECK(na * deg == av2v.size());
LOs const v2vb = v2b.a2ab;
LOs const vb2b = v2b.ab2b;
Read<I8> const vb_codes = v2b.codes;
Write<LO> a2b(na);
Write<I8> codes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto const fv = a2fv[a];
auto const a_begin = a * deg;
auto const vb_begin = v2vb[fv];
auto const vb_end = v2vb[fv + 1];
bool found = false;
for (LO vb = vb_begin; vb < vb_end; ++vb) {
auto const b = vb2b[vb];
auto const vb_code = vb_codes[vb];
auto const which_down = code_which_down(vb_code);
auto const b_begin = b * deg;
I8 match_code;
if (IsMatch<deg>::eval(
av2v, a_begin, bv2v, b_begin, which_down, &match_code)) {
OMEGA_H_CHECK(!found); // there can't be more than one!
a2b[a] = b;
codes[a] = match_code;
found = true;
if (allow_duplicates) break;
}
}
(void)found;
OMEGA_H_CHECK(found); // there can't be less than one!
};
parallel_for(na, std::move(f));
*a2b_out = a2b;
*codes_out = codes;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x16add0(%rip), %rsi # 0x277797
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xef870
leaq 0x16a8b8(%rip), %rdx # 0x277295
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xed920
leaq 0x30(%rsp), %rdi
movl $0x169, %esi # imm = 0x169
callq 0xf9ed0
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xf4ff0
movq %r13, 0x28(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x16b111(%rip), %rdi # 0x277b37
callq 0xf9c20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
movq (%rbp), %r13
testb $0x1, %r13b
jne 0x10ca66
movq (%r13), %r13
jmp 0x10ca6a
shrq $0x3, %r13
shrq $0x2, %r13
leal (,%r13,2), %eax
movq (%r12), %rcx
testb $0x1, %cl
jne 0x10ca84
movq (%rcx), %rcx
jmp 0x10ca88
shrq $0x3, %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jne 0x10cc61
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0xf0580
leaq 0x10(%rbx), %rsi
leaq 0x50(%rsp), %rdi
callq 0xf0580
addq $0x20, %rbx
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8e10
leaq 0x1709f0(%rip), %rsi # 0x27d4b7
leaq 0x90(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl %r13d, %esi
callq 0xedf20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x1709b5(%rip), %rsi # 0x27d4b7
leaq 0x90(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl %r13d, %esi
callq 0xf0f30
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
movq %rbp, %rsi
callq 0xf0580
leaq 0xa0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xf0580
leaq 0xb0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xf0580
leaq 0xc0(%rsp), %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8e10
leaq 0xd0(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0xf0(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xf0580
leaq 0x100(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf8e10
movb 0x150(%rsp), %al
leaq 0x90(%rsp), %rsi
movb %al, 0x80(%rsi)
movl %r13d, %edi
callq 0xef4e0
leaq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0xf7670
leaq 0x18(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xec7d0
leaq 0x90(%rsp), %rdi
callq 0xf81a0
movq %rbx, %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16a420(%rip), %rdi # 0x277088
leaq 0x16aed9(%rip), %rsi # 0x277b48
leaq 0x16ab21(%rip), %rdx # 0x277797
movl $0x16b, %ecx # imm = 0x16B
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %r13
movq %r15, %rdi
callq 0xff620
jmp 0x10cc92
movq %rax, %r13
movq %r12, %rdi
callq 0xff620
jmp 0x10cc9f
movq %rax, %r13
movq %rbp, %rdi
callq 0xff620
jmp 0x10ccac
movq %rax, %r13
movq %rbx, %rdi
callq 0xf9e00
jmp 0x10ccb9
movq %rax, %r13
leaq 0xb0(%rsp), %rdi
callq 0xff620
leaq 0xa0(%rsp), %rdi
callq 0xff620
leaq 0x90(%rsp), %rdi
callq 0xff620
jmp 0x10cd9f
movq %rax, %r13
jmp 0x10ccc6
movq %rax, %r13
jmp 0x10ccd3
movq %rax, %r13
jmp 0x10cd9f
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10cda9
movq %rax, %r13
jmp 0x10cda9
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10cdb3
movq %rax, %r13
jmp 0x10cdb3
movq %rax, %r13
jmp 0x10cdbd
movq %rax, %r13
jmp 0x10cdc7
jmp 0x10cd43
movq %rax, %r13
jmp 0x10cdd1
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10cd60
movq %rax, %r13
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x10cd6f
movq %rax, %r13
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x10cd7e
movq %rax, %r13
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x10cddb
movq %rax, %r13
jmp 0x10cddb
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf81a0
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %r13, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
void Omega_h::find_matches_deg<4, int>(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Adj, Omega_h::Write<int>*, Omega_h::Write<signed char>*, bool)
|
void find_matches_deg(LOs const a2fv, Read<T> const av2v,
Read<T> const bv2v, Adj const v2b, Write<LO>* a2b_out, Write<I8>* codes_out,
bool const allow_duplicates) {
OMEGA_H_TIME_FUNCTION;
LO const na = a2fv.size();
OMEGA_H_CHECK(na * deg == av2v.size());
LOs const v2vb = v2b.a2ab;
LOs const vb2b = v2b.ab2b;
Read<I8> const vb_codes = v2b.codes;
Write<LO> a2b(na);
Write<I8> codes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto const fv = a2fv[a];
auto const a_begin = a * deg;
auto const vb_begin = v2vb[fv];
auto const vb_end = v2vb[fv + 1];
bool found = false;
for (LO vb = vb_begin; vb < vb_end; ++vb) {
auto const b = vb2b[vb];
auto const vb_code = vb_codes[vb];
auto const which_down = code_which_down(vb_code);
auto const b_begin = b * deg;
I8 match_code;
if (IsMatch<deg>::eval(
av2v, a_begin, bv2v, b_begin, which_down, &match_code)) {
OMEGA_H_CHECK(!found); // there can't be more than one!
a2b[a] = b;
codes[a] = match_code;
found = true;
if (allow_duplicates) break;
}
}
(void)found;
OMEGA_H_CHECK(found); // there can't be less than one!
};
parallel_for(na, std::move(f));
*a2b_out = a2b;
*codes_out = codes;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x16a4f6(%rip), %rsi # 0x277797
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xef870
leaq 0x169fde(%rip), %rdx # 0x277295
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xed920
leaq 0x30(%rsp), %rdi
movl $0x169, %esi # imm = 0x169
callq 0xf9ed0
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xf4ff0
movq %r13, 0x28(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x16a837(%rip), %rdi # 0x277b37
callq 0xf9c20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
movq (%rbp), %r13
testb $0x1, %r13b
jne 0x10d340
movq (%r13), %r13
jmp 0x10d344
shrq $0x3, %r13
shrq $0x2, %r13
leal (,%r13,4), %eax
movq (%r12), %rcx
testb $0x1, %cl
jne 0x10d35e
movq (%rcx), %rcx
jmp 0x10d362
shrq $0x3, %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jne 0x10d53b
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0xf0580
leaq 0x10(%rbx), %rsi
leaq 0x50(%rsp), %rdi
callq 0xf0580
addq $0x20, %rbx
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8e10
leaq 0x170116(%rip), %rsi # 0x27d4b7
leaq 0x90(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl %r13d, %esi
callq 0xedf20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x1700db(%rip), %rsi # 0x27d4b7
leaq 0x90(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl %r13d, %esi
callq 0xf0f30
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
movq %rbp, %rsi
callq 0xf0580
leaq 0xa0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xf0580
leaq 0xb0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xf0580
leaq 0xc0(%rsp), %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8e10
leaq 0xd0(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf0580
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0xf0(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xf0580
leaq 0x100(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf8e10
movb 0x150(%rsp), %al
leaq 0x90(%rsp), %rsi
movb %al, 0x80(%rsi)
movl %r13d, %edi
callq 0xfe350
leaq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0xf7670
leaq 0x18(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xec7d0
leaq 0x90(%rsp), %rdi
callq 0xf5ea0
movq %rbx, %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x169b46(%rip), %rdi # 0x277088
leaq 0x16a5ff(%rip), %rsi # 0x277b48
leaq 0x16a247(%rip), %rdx # 0x277797
movl $0x16b, %ecx # imm = 0x16B
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %r13
movq %r15, %rdi
callq 0xff620
jmp 0x10d56c
movq %rax, %r13
movq %r12, %rdi
callq 0xff620
jmp 0x10d579
movq %rax, %r13
movq %rbp, %rdi
callq 0xff620
jmp 0x10d586
movq %rax, %r13
movq %rbx, %rdi
callq 0xf9e00
jmp 0x10d593
movq %rax, %r13
leaq 0xb0(%rsp), %rdi
callq 0xff620
leaq 0xa0(%rsp), %rdi
callq 0xff620
leaq 0x90(%rsp), %rdi
callq 0xff620
jmp 0x10d679
movq %rax, %r13
jmp 0x10d5a0
movq %rax, %r13
jmp 0x10d5ad
movq %rax, %r13
jmp 0x10d679
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10d683
movq %rax, %r13
jmp 0x10d683
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10d68d
movq %rax, %r13
jmp 0x10d68d
movq %rax, %r13
jmp 0x10d697
movq %rax, %r13
jmp 0x10d6a1
jmp 0x10d61d
movq %rax, %r13
jmp 0x10d6ab
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10d63a
movq %rax, %r13
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x10d649
movq %rax, %r13
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x10d658
movq %rax, %r13
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x10d6b5
movq %rax, %r13
jmp 0x10d6b5
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf5ea0
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %r13, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical<long>(int, Omega_h::Read<long>)
|
Read<I8> get_codes_to_canonical(Int const deg, Read<T> const ev2v) {
OMEGA_H_TIME_FUNCTION;
if (deg == 4) return get_codes_to_canonical_deg<4>(ev2v);
if (deg == 3) return get_codes_to_canonical_deg<3>(ev2v);
if (deg == 2) return get_codes_to_canonical_deg<2>(ev2v);
OMEGA_H_NORETURN(Read<I8>());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x16a0be(%rip), %rsi # 0x277797
leaq 0x58(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x169ba6(%rip), %rdx # 0x277295
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xed920
leaq 0x38(%rsp), %rdi
pushq $0x63
popq %rsi
callq 0xf9ed0
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0xf4ff0
movq 0x98(%rsp), %rsi
leaq 0x16a04f(%rip), %rdi # 0x277780
callq 0xf9c20
leaq 0x98(%rsp), %rdi
callq 0xf00f0
leaq 0x38(%rsp), %rdi
callq 0xf00f0
leaq 0x78(%rsp), %rdi
callq 0xf00f0
leaq 0x58(%rsp), %rdi
callq 0xf00f0
cmpl $0x2, %ebp
je 0x10d7aa
cmpl $0x3, %ebp
je 0x10d78d
cmpl $0x4, %ebp
jne 0x10d7e8
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3b80
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf0a30
jmp 0x10d7c5
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3b80
movq %rbx, %rdi
movq %r15, %rsi
callq 0xf66e0
jmp 0x10d7c5
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3b80
movq %rbx, %rdi
movq %r15, %rsi
callq 0xef0c0
movq %r15, %rdi
callq 0x100060
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x169899(%rip), %rdi # 0x277088
leaq 0x169fff(%rip), %rsi # 0x2777f5
leaq 0x169f9a(%rip), %rdx # 0x277797
pushq $0x67
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x10d823
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x10d823
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x100060
jmp 0x10d871
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0xf00f0
jmp 0x10d83f
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf00f0
jmp 0x10d84e
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0xf00f0
jmp 0x10d85d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf00f0
jmp 0x10d87b
movq %rax, %rbx
jmp 0x10d87b
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical_deg<4, long>(Omega_h::Read<long>)
|
Read<I8> get_codes_to_canonical_deg(Read<T> const ev2v) {
auto const nev = ev2v.size();
auto const ne = divide_no_remainder(nev, deg);
Write<I8> codes(ne);
auto f = OMEGA_H_LAMBDA(LO e) {
auto const begin = e * deg;
/* find the smallest vertex */
Int min_j = 0;
auto min_v = ev2v[begin];
for (Int j = 1; j < deg; ++j) {
auto const ev = j + begin;
auto const v = ev2v[ev];
if (v < min_v) {
min_j = j;
min_v = v;
}
}
/* rotate to make it first */
auto const rotation = rotation_to_first(deg, min_j);
T tmp[deg];
rotate_adj<deg>(rotation, ev2v, begin, tmp, 0);
auto const is_flipped = IsFlipped<deg>::is(tmp);
codes[e] = make_code(is_flipped, rotation, 0);
};
parallel_for(ne, std::move(f));
return codes;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x10d89f
movq (%rdi), %rdi
jmp 0x10d8a3
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x4
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x16fbff(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl %ebp, %esi
callq 0xf0f30
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf3b80
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf8e10
leaq 0x10(%rsp), %rsi
movl %ebp, %edi
callq 0x101cb0
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x100b80
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x40(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0x100f40
leaq 0x30(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x10d98a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x100060
jmp 0x10d994
movq %rax, %rbx
jmp 0x10d994
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x10d99e
movq %rax, %rbx
jmp 0x10d99e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x100f40
leaq 0x30(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::Read<signed char> Omega_h::get_codes_to_canonical_deg<3, long>(Omega_h::Read<long>)
|
Read<I8> get_codes_to_canonical_deg(Read<T> const ev2v) {
auto const nev = ev2v.size();
auto const ne = divide_no_remainder(nev, deg);
Write<I8> codes(ne);
auto f = OMEGA_H_LAMBDA(LO e) {
auto const begin = e * deg;
/* find the smallest vertex */
Int min_j = 0;
auto min_v = ev2v[begin];
for (Int j = 1; j < deg; ++j) {
auto const ev = j + begin;
auto const v = ev2v[ev];
if (v < min_v) {
min_j = j;
min_v = v;
}
}
/* rotate to make it first */
auto const rotation = rotation_to_first(deg, min_j);
T tmp[deg];
rotate_adj<deg>(rotation, ev2v, begin, tmp, 0);
auto const is_flipped = IsFlipped<deg>::is(tmp);
codes[e] = make_code(is_flipped, rotation, 0);
};
parallel_for(ne, std::move(f));
return codes;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x10d9c2
movq (%rdi), %rdi
jmp 0x10d9c6
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
leaq 0x16fadc(%rip), %rsi # 0x27d4b7
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl %ebp, %esi
callq 0xf0f30
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf3b80
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xf8e10
leaq 0x10(%rsp), %rsi
movl %ebp, %edi
callq 0xef930
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x100b80
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x40(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xf2aa0
leaq 0x30(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x10daad
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x100060
jmp 0x10dab7
movq %rax, %rbx
jmp 0x10dab7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x10dac1
movq %rax, %rbx
jmp 0x10dac1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf2aa0
leaq 0x30(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
void Omega_h::find_matches_deg<2, long>(Omega_h::Read<int>, Omega_h::Read<long>, Omega_h::Read<long>, Omega_h::Adj, Omega_h::Write<int>*, Omega_h::Write<signed char>*, bool)
|
void find_matches_deg(LOs const a2fv, Read<T> const av2v,
Read<T> const bv2v, Adj const v2b, Write<LO>* a2b_out, Write<I8>* codes_out,
bool const allow_duplicates) {
OMEGA_H_TIME_FUNCTION;
LO const na = a2fv.size();
OMEGA_H_CHECK(na * deg == av2v.size());
LOs const v2vb = v2b.a2ab;
LOs const vb2b = v2b.ab2b;
Read<I8> const vb_codes = v2b.codes;
Write<LO> a2b(na);
Write<I8> codes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto const fv = a2fv[a];
auto const a_begin = a * deg;
auto const vb_begin = v2vb[fv];
auto const vb_end = v2vb[fv + 1];
bool found = false;
for (LO vb = vb_begin; vb < vb_end; ++vb) {
auto const b = vb2b[vb];
auto const vb_code = vb_codes[vb];
auto const which_down = code_which_down(vb_code);
auto const b_begin = b * deg;
I8 match_code;
if (IsMatch<deg>::eval(
av2v, a_begin, bv2v, b_begin, which_down, &match_code)) {
OMEGA_H_CHECK(!found); // there can't be more than one!
a2b[a] = b;
codes[a] = match_code;
found = true;
if (allow_duplicates) break;
}
}
(void)found;
OMEGA_H_CHECK(found); // there can't be less than one!
};
parallel_for(na, std::move(f));
*a2b_out = a2b;
*codes_out = codes;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x169911(%rip), %rsi # 0x277797
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xef870
leaq 0x1693f9(%rip), %rdx # 0x277295
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xed920
leaq 0x30(%rsp), %rdi
movl $0x169, %esi # imm = 0x169
callq 0xf9ed0
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xf4ff0
movq %r13, 0x28(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x169c52(%rip), %rdi # 0x277b37
callq 0xf9c20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
movq (%rbp), %r13
testb $0x1, %r13b
jne 0x10df25
movq (%r13), %r13
jmp 0x10df29
shrq $0x3, %r13
shrq $0x2, %r13
leal (,%r13,2), %eax
movq (%r12), %rcx
testb $0x1, %cl
jne 0x10df43
movq (%rcx), %rcx
jmp 0x10df47
shrq $0x3, %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x10e120
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0xf0580
leaq 0x10(%rbx), %rsi
leaq 0x50(%rsp), %rdi
callq 0xf0580
addq $0x20, %rbx
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8e10
leaq 0x16f531(%rip), %rsi # 0x27d4b7
leaq 0x90(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl %r13d, %esi
callq 0xedf20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x16f4f6(%rip), %rsi # 0x27d4b7
leaq 0x90(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl %r13d, %esi
callq 0xf0f30
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
movq %rbp, %rsi
callq 0xf0580
leaq 0xa0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xf0580
leaq 0xb0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xf0580
leaq 0xc0(%rsp), %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8e10
leaq 0xd0(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf3b80
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf3b80
leaq 0xf0(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xf0580
leaq 0x100(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf8e10
movb 0x150(%rsp), %al
leaq 0x90(%rsp), %rsi
movb %al, 0x80(%rsi)
movl %r13d, %edi
callq 0xf7fc0
leaq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0xf7670
leaq 0x18(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xec7d0
leaq 0x90(%rsp), %rdi
callq 0xece60
movq %rbx, %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x168f61(%rip), %rdi # 0x277088
leaq 0x169a1a(%rip), %rsi # 0x277b48
leaq 0x169662(%rip), %rdx # 0x277797
movl $0x16b, %ecx # imm = 0x16B
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %r13
movq %r15, %rdi
callq 0xff620
jmp 0x10e151
movq %rax, %r13
movq %r12, %rdi
callq 0x100060
jmp 0x10e15e
movq %rax, %r13
movq %rbp, %rdi
callq 0x100060
jmp 0x10e16b
movq %rax, %r13
movq %rbx, %rdi
callq 0xf9e00
jmp 0x10e178
movq %rax, %r13
leaq 0xb0(%rsp), %rdi
callq 0xff620
leaq 0xa0(%rsp), %rdi
callq 0xff620
leaq 0x90(%rsp), %rdi
callq 0xff620
jmp 0x10e25e
movq %rax, %r13
jmp 0x10e185
movq %rax, %r13
jmp 0x10e192
movq %rax, %r13
jmp 0x10e25e
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10e268
movq %rax, %r13
jmp 0x10e268
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10e272
movq %rax, %r13
jmp 0x10e272
movq %rax, %r13
jmp 0x10e27c
movq %rax, %r13
jmp 0x10e286
jmp 0x10e202
movq %rax, %r13
jmp 0x10e290
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10e21f
movq %rax, %r13
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x10e22e
movq %rax, %r13
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x10e23d
movq %rax, %r13
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x10e29a
movq %rax, %r13
jmp 0x10e29a
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xece60
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %r13, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
void Omega_h::find_matches_deg<3, long>(Omega_h::Read<int>, Omega_h::Read<long>, Omega_h::Read<long>, Omega_h::Adj, Omega_h::Write<int>*, Omega_h::Write<signed char>*, bool)
|
void find_matches_deg(LOs const a2fv, Read<T> const av2v,
Read<T> const bv2v, Adj const v2b, Write<LO>* a2b_out, Write<I8>* codes_out,
bool const allow_duplicates) {
OMEGA_H_TIME_FUNCTION;
LO const na = a2fv.size();
OMEGA_H_CHECK(na * deg == av2v.size());
LOs const v2vb = v2b.a2ab;
LOs const vb2b = v2b.ab2b;
Read<I8> const vb_codes = v2b.codes;
Write<LO> a2b(na);
Write<I8> codes(na);
auto f = OMEGA_H_LAMBDA(LO a) {
auto const fv = a2fv[a];
auto const a_begin = a * deg;
auto const vb_begin = v2vb[fv];
auto const vb_end = v2vb[fv + 1];
bool found = false;
for (LO vb = vb_begin; vb < vb_end; ++vb) {
auto const b = vb2b[vb];
auto const vb_code = vb_codes[vb];
auto const which_down = code_which_down(vb_code);
auto const b_begin = b * deg;
I8 match_code;
if (IsMatch<deg>::eval(
av2v, a_begin, bv2v, b_begin, which_down, &match_code)) {
OMEGA_H_CHECK(!found); // there can't be more than one!
a2b[a] = b;
codes[a] = match_code;
found = true;
if (allow_duplicates) break;
}
}
(void)found;
OMEGA_H_CHECK(found); // there can't be less than one!
};
parallel_for(na, std::move(f));
*a2b_out = a2b;
*codes_out = codes;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
leaq 0x1694cb(%rip), %rsi # 0x277797
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xef870
leaq 0x168fb3(%rip), %rdx # 0x277295
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xed920
leaq 0x30(%rsp), %rdi
movl $0x169, %esi # imm = 0x169
callq 0xf9ed0
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xf4ff0
movq %r13, 0x28(%rsp)
movq 0x90(%rsp), %rsi
leaq 0x16980c(%rip), %rdi # 0x277b37
callq 0xf9c20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
movq (%rbp), %r13
testb $0x1, %r13b
jne 0x10e36b
movq (%r13), %r13
jmp 0x10e36f
shrq $0x3, %r13
shrq $0x2, %r13
leal (%r13,%r13,2), %eax
movq (%r12), %rcx
testb $0x1, %cl
jne 0x10e386
movq (%rcx), %rcx
jmp 0x10e38a
shrq $0x3, %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x10e563
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0xf0580
leaq 0x10(%rbx), %rsi
leaq 0x50(%rsp), %rdi
callq 0xf0580
addq $0x20, %rbx
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8e10
leaq 0x16f0ee(%rip), %rsi # 0x27d4b7
leaq 0x90(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl %r13d, %esi
callq 0xedf20
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x16f0b3(%rip), %rsi # 0x27d4b7
leaq 0x90(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x18(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl %r13d, %esi
callq 0xf0f30
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
movq %rbp, %rsi
callq 0xf0580
leaq 0xa0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xf0580
leaq 0xb0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xf0580
leaq 0xc0(%rsp), %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8e10
leaq 0xd0(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xf3b80
leaq 0xe0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf3b80
leaq 0xf0(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0xf0580
leaq 0x100(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf8e10
movb 0x150(%rsp), %al
leaq 0x90(%rsp), %rsi
movb %al, 0x80(%rsi)
movl %r13d, %edi
callq 0xf4570
leaq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0xf7670
leaq 0x18(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xec7d0
leaq 0x90(%rsp), %rdi
callq 0xed880
movq %rbx, %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x168b1e(%rip), %rdi # 0x277088
leaq 0x1695d7(%rip), %rsi # 0x277b48
leaq 0x16921f(%rip), %rdx # 0x277797
movl $0x16b, %ecx # imm = 0x16B
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %r13
movq %r15, %rdi
callq 0xff620
jmp 0x10e594
movq %rax, %r13
movq %r12, %rdi
callq 0x100060
jmp 0x10e5a1
movq %rax, %r13
movq %rbp, %rdi
callq 0x100060
jmp 0x10e5ae
movq %rax, %r13
movq %rbx, %rdi
callq 0xf9e00
jmp 0x10e5bb
movq %rax, %r13
leaq 0xb0(%rsp), %rdi
callq 0xff620
leaq 0xa0(%rsp), %rdi
callq 0xff620
leaq 0x90(%rsp), %rdi
callq 0xff620
jmp 0x10e6a1
movq %rax, %r13
jmp 0x10e5c8
movq %rax, %r13
jmp 0x10e5d5
movq %rax, %r13
jmp 0x10e6a1
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10e6ab
movq %rax, %r13
jmp 0x10e6ab
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10e6b5
movq %rax, %r13
jmp 0x10e6b5
movq %rax, %r13
jmp 0x10e6bf
movq %rax, %r13
jmp 0x10e6c9
jmp 0x10e645
movq %rax, %r13
jmp 0x10e6d3
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x10e662
movq %rax, %r13
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x10e671
movq %rax, %r13
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x10e680
movq %rax, %r13
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x10e6dd
movq %rax, %r13
jmp 0x10e6dd
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0xed880
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xff620
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x50(%rsp), %rdi
callq 0xff620
leaq 0x70(%rsp), %rdi
callq 0xff620
leaq 0x6(%rsp), %rdi
callq 0xf7d50
movq %r13, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::Write<int>::~Write()
|
OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); }
|
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
sete %al
testb $0x7, %bl
setne %cl
orb %al, %cl
jne 0x10eb45
decl 0x30(%rbx)
je 0x10eb47
popq %rbx
retq
movq %rbx, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xf6cf0
nop
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::Write<int>::Write(Omega_h::Write<int> const&)
|
OMEGA_H_INLINE void copy(SharedAlloc const& other) noexcept {
alloc = other.alloc;
#ifndef __CUDA_ARCH__
if (alloc && (!(reinterpret_cast<std::uintptr_t>(alloc) & FREE_MASK))) {
// allocated
if (entering_parallel) {
alloc = reinterpret_cast<Alloc*>(
(std::uintptr_t(alloc->size) << 3) | IN_PARALLEL);
} else {
++(alloc->use_count);
}
}
#endif
direct_ptr = other.direct_ptr;
}
|
movq (%rsi), %rax
movq %rax, (%rdi)
testq %rax, %rax
sete %cl
testb $0x7, %al
setne %dl
orb %cl, %dl
jne 0x10eb90
movq 0x203148(%rip), %rcx # 0x311cc0
cmpb $0x1, (%rcx)
jne 0x10eb8d
movq (%rax), %rax
leaq 0x1(,%rax,8), %rax
movq %rax, (%rdi)
jmp 0x10eb90
incl 0x30(%rax)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::Write<signed char>::~Write()
|
OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); }
|
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
sete %al
testb $0x7, %bl
setne %cl
orb %al, %cl
jne 0x10ebf1
decl 0x30(%rbx)
je 0x10ebf3
popq %rbx
retq
movq %rbx, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xf6cf0
nop
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::Adj::Adj(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>)
|
Adj(LOs a2ab_, LOs ab2b_, Read<I8> codes_)
: Graph(a2ab_, ab2b_), codes(codes_) {}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf0580
movq %rsp, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xf6db0
movq %rsp, %rdi
callq 0xff620
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xf8e10
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xfe010
jmp 0x10ec8e
movq %rax, %r14
movq %rsp, %rdi
callq 0xff620
jmp 0x10ec84
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xff620
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.hpp
|
Omega_h::Write<signed char>::Write(Omega_h::Write<signed char>&&)
|
OMEGA_H_INLINE void move(SharedAlloc&& other) noexcept {
alloc = other.alloc;
direct_ptr = other.direct_ptr;
#ifndef __CUDA_ARCH__
if (alloc && (!(reinterpret_cast<std::uintptr_t>(alloc) & FREE_MASK))) {
// allocated
if (entering_parallel) {
--(alloc->use_count);
alloc = reinterpret_cast<Alloc*>(
(std::uintptr_t(alloc->size) << 3) | IN_PARALLEL);
}
}
#endif
other.alloc = nullptr;
other.direct_ptr = nullptr;
}
|
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rax, %rax
sete %cl
testb $0x7, %al
setne %dl
orb %cl, %dl
jne 0x10ecd0
movq 0x203006(%rip), %rcx # 0x311cc0
cmpb $0x1, (%rcx)
jne 0x10ecd0
decl 0x30(%rax)
movq (%rax), %rax
leaq 0x1(,%rax,8), %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::Write<int>::Write(Omega_h::Write<int>&&)
|
OMEGA_H_INLINE void move(SharedAlloc&& other) noexcept {
alloc = other.alloc;
direct_ptr = other.direct_ptr;
#ifndef __CUDA_ARCH__
if (alloc && (!(reinterpret_cast<std::uintptr_t>(alloc) & FREE_MASK))) {
// allocated
if (entering_parallel) {
--(alloc->use_count);
alloc = reinterpret_cast<Alloc*>(
(std::uintptr_t(alloc->size) << 3) | IN_PARALLEL);
}
}
#endif
other.alloc = nullptr;
other.direct_ptr = nullptr;
}
|
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rdi)
testq %rax, %rax
sete %cl
testb $0x7, %al
setne %dl
orb %cl, %dl
jne 0x10ed5e
movq 0x202f78(%rip), %rcx # 0x311cc0
cmpb $0x1, (%rcx)
jne 0x10ed5e
decl 0x30(%rax)
movq (%rax), %rax
leaq 0x1(,%rax,8), %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
retq
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::Children::Children(Omega_h::Read<int>, Omega_h::Read<int>, Omega_h::Read<signed char>)
|
Children(LOs a2ab_, LOs ab2b_, Read<I8> codes_)
: Graph(a2ab_, ab2b_), codes(codes_) {}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0xf0580
movq %rsp, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xf6db0
movq %rsp, %rdi
callq 0xff620
leaq 0x10(%rsp), %rdi
callq 0xff620
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xf8e10
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xfe010
jmp 0x10eea4
movq %rax, %r14
movq %rsp, %rdi
callq 0xff620
jmp 0x10ee9a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xff620
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.hpp
|
Omega_h::Adj::Adj(Omega_h::Read<int>, Omega_h::Read<signed char>)
|
Adj(LOs ab2b_, Read<I8> codes_) : Graph(ab2b_), codes(codes_) {}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0xf0580
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfecc0
movq %rsp, %rdi
callq 0xff620
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xf8e10
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xfe010
jmp 0x10ef9f
movq %rax, %r14
movq %rsp, %rdi
callq 0xff620
movq %r14, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_adj.hpp
|
Omega_h::elements_across_sides_count_functor::elements_across_sides_count_functor(int, Omega_h::Read<int> const&, Omega_h::Read<signed char> const&, Omega_h::Write<int> const&)
|
elements_across_sides_count_functor(
Int nsides_per_elem_arg,
Read<LO> const& elem_side2side_arg,
Read<I8> const& side_is_exposed_arg,
Write<LO> const& degrees_arg
)
:nsides_per_elem(nsides_per_elem_arg)
,elem_side2side(elem_side2side_arg)
,side_is_exposed(side_is_exposed_arg)
,degrees(degrees_arg)
{}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdi, %r12
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf0580
leaq 0x18(%r12), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xf8e10
addq $0x28, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xf0580
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0xf9e00
jmp 0x10f298
movq %rax, %r14
movq %rbx, %rdi
callq 0xff620
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_adj.cpp
|
Omega_h::Write<long>::~Write()
|
OMEGA_H_INLINE LO size() const OMEGA_H_NOEXCEPT { return write_.size(); }
|
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
sete %al
testb $0x7, %bl
setne %cl
orb %al, %cl
jne 0x10f393
decl 0x30(%rbx)
je 0x10f395
popq %rbx
retq
movq %rbx, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0xf6cf0
nop
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::Read<long> Omega_h::align_ev2v_deg<2, long>(Omega_h::Read<long>, Omega_h::Read<signed char>)
|
Read<T> align_ev2v_deg(Read<T> ev2v, Read<I8> codes) {
OMEGA_H_CHECK(ev2v.size() == codes.size() * deg);
auto ne = codes.size();
Write<T> ev2v_w(ev2v.size());
auto f = OMEGA_H_LAMBDA(LO e) {
align_adj<deg>(codes[e], ev2v, e * deg, ev2v_w, e * deg);
};
parallel_for(ne, f, "align_ev2v");
return ev2v_w;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r13
testb $0x1, %r13b
jne 0x1126d0
movq (%r13), %rax
jmp 0x1126d7
movq %r13, %rax
shrq $0x3, %rax
shrq $0x3, %rax
movq (%r12), %r14
testb $0x1, %r14b
jne 0x1126f5
movl (%r14), %r14d
leal (%r14,%r14), %ecx
cmpl %eax, %ecx
je 0x11270b
jmp 0x1127dc
movq %r14, %rcx
shrq $0x2, %rcx
andl $-0x2, %ecx
cmpl %eax, %ecx
jne 0x1127dc
shrq $0x3, %r14
testb $0x1, %r13b
jne 0x112717
movq (%r13), %r13
jmp 0x11271b
shrq $0x3, %r13
leaq 0x16ad95(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
shrq $0x3, %r13
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl %r13d, %esi
callq 0xecc90
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf3b80
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf3b80
leaq 0x16547e(%rip), %rdx # 0x277c02
leaq 0x30(%rsp), %rsi
movl %r14d, %edi
callq 0xeff20
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xee9e0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xece80
leaq 0x20(%rsp), %rdi
callq 0x100060
leaq 0x30(%rsp), %rdi
callq 0xf0a90
leaq 0x10(%rsp), %rdi
callq 0x100060
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1648a5(%rip), %rdi # 0x277088
leaq 0x1653f6(%rip), %rsi # 0x277be0
leaq 0x16538f(%rip), %rdx # 0x277b80
pushq $0x9
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x100060
jmp 0x112842
movq %rax, %rbx
movq %r12, %rdi
callq 0x100060
jmp 0x11281a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf9e00
jmp 0x11284c
movq %rax, %rbx
jmp 0x11284c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x112856
movq %rax, %rbx
jmp 0x112856
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf0a90
leaq 0x10(%rsp), %rdi
callq 0x100060
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_align.cpp
|
void Omega_h::parallel_for<Omega_h::Read<int> Omega_h::align_ev2v_deg<2, int>(Omega_h::Read<int>, Omega_h::Read<signed char>)::'lambda'(int)>(int, Omega_h::Read<int> Omega_h::align_ev2v_deg<2, int>(Omega_h::Read<int>, Omega_h::Read<signed char>)::'lambda'(int) const&, char const*)
|
void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf89c0
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf2220
leaq 0x8(%rsp), %rdi
callq 0xf1db0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf1db0
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
Omega_h::Read<int> Omega_h::align_ev2v_deg<2, int>(Omega_h::Read<int>, Omega_h::Read<signed char>)::'lambda'(int)::operator()(int) const
|
OMEGA_H_DEVICE T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return view_(i);
#else
return data()[i];
#endif
}
|
movslq %esi, %rax
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rcx
movzbl (%rdx,%rax), %edx
addl %eax, %eax
movslq %eax, %rsi
shrl %edx
shlq $0x2, %rsi
addq 0x18(%rdi), %rsi
xorl %edi, %edi
cmpq $0x2, %rdi
je 0x112e0b
leal (%rdx,%rdi), %r8d
andl $0x1, %r8d
movl (%rsi,%rdi,4), %r9d
orl %eax, %r8d
movslq %r8d, %r8
movl %r9d, (%rcx,%r8,4)
incq %rdi
jmp 0x112dea
retq
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
void Omega_h::parallel_for<Omega_h::Read<long> Omega_h::align_ev2v_deg<4, long>(Omega_h::Read<long>, Omega_h::Read<signed char>)::'lambda'(int)>(int, Omega_h::Read<long> Omega_h::align_ev2v_deg<4, long>(Omega_h::Read<long>, Omega_h::Read<signed char>)::'lambda'(int) const&, char const*)
|
void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x100730
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rdx
callq 0xf1f70
leaq 0x8(%rsp), %rdi
callq 0xf0c80
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf0c80
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_for.hpp
|
Omega_h::Read<long> Omega_h::align_ev2v_deg<4, long>(Omega_h::Read<long>, Omega_h::Read<signed char>)::'lambda'(int)::operator()(int) const
|
OMEGA_H_DEVICE T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return view_(i);
#else
return data()[i];
#endif
}
|
movslq %esi, %rcx
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rax
movzbl (%rdx,%rcx), %edx
shll $0x2, %ecx
movslq %ecx, %rsi
movl %edx, %r8d
shrl %r8d
shlq $0x3, %rsi
addq 0x18(%rdi), %rsi
xorl %edi, %edi
cmpq $0x4, %rdi
je 0x113018
leal (%r8,%rdi), %r9d
andl $0x3, %r9d
movq (%rsi,%rdi,8), %r10
orl %ecx, %r9d
movslq %r9d, %r9
movq %r10, (%rax,%r9,8)
incq %rdi
jmp 0x112ff7
testb $0x1, %dl
je 0x11303b
movl %ecx, %edx
orl $0x1, %edx
movslq %edx, %rdx
orl $0x3, %ecx
movslq %ecx, %rcx
movq (%rax,%rdx,8), %rsi
movq (%rax,%rcx,8), %rdi
movq %rdi, (%rax,%rdx,8)
movq %rsi, (%rax,%rcx,8)
retq
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::Write<signed char>::Write(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
Write<T>::Write(LO size_in, std::string const& name_in) {
begin_code("Write allocation");
#ifdef OMEGA_H_USE_KOKKOS
view_ = decltype(view_)(Kokkos::ViewAllocateWithoutInitializing(name_in),
static_cast<std::size_t>(size_in));
#else
shared_alloc_ = decltype(shared_alloc_)(
sizeof(T) * static_cast<std::size_t>(size_in), name_in);
#endif
end_code();
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x15a998(%rip), %rdi # 0x27896d
xorl %esi, %esi
callq 0xf9c20
movslq %ebp, %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0xf8970
movq (%rbx), %r14
testq %r14, %r14
sete %al
testb $0x7, %r14b
setne %cl
orb %al, %cl
jne 0x11e017
decl 0x30(%r14)
jne 0x11e017
movq %r14, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0xf6cf0
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rbx)
testq %rax, %rax
sete %cl
testb $0x7, %al
setne %dl
orb %cl, %dl
jne 0x11e053
movq 0x1f3c83(%rip), %rcx # 0x311cc0
cmpb $0x1, (%rcx)
jne 0x11e053
decl 0x30(%rax)
movq (%rax), %rax
leaq 0x1(,%rax,8), %rax
movq %rax, (%rbx)
callq 0xfb6a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11e063
movq %rax, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
sete %al
testb $0x7, %bl
setne %cl
orb %al, %cl
jne 0x11e091
decl 0x30(%rbx)
jne 0x11e091
movq %rbx, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0xf6cf0
movq %r14, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array.cpp
|
void Omega_h::fill<signed char>(Omega_h::Write<signed char>, signed char)
|
void fill(Write<T> a, T val) {
auto f = OMEGA_H_LAMBDA(LO i) { a[i] = val; };
parallel_for(a.size(), f, "Write(size,value)");
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movb %bl, 0x10(%r15)
movq (%r14), %rdi
testb $0x1, %dil
jne 0x11e127
movq (%rdi), %rdi
jmp 0x11e12b
shrq $0x3, %rdi
leaq 0x15a8a2(%rip), %rdx # 0x2789d4
leaq 0x8(%rsp), %rsi
callq 0xf4ec0
leaq 0x8(%rsp), %rdi
callq 0xf9e00
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array.cpp
|
void Omega_h::fill_linear<signed char>(Omega_h::Write<signed char>, signed char, signed char)
|
void fill_linear(Write<T> a, T offset, T stride) {
auto f = OMEGA_H_LAMBDA(LO i) {
a[i] = offset + (stride * static_cast<T>(i));
};
parallel_for(a.size(), f, "Write(size,offset,stride)");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movb %bpl, 0x10(%r15)
movb %bl, 0x11(%r15)
movq (%r14), %rdi
testb $0x1, %dil
jne 0x11e1ff
movq (%rdi), %rdi
jmp 0x11e203
shrq $0x3, %rdi
leaq 0x15a7dc(%rip), %rdx # 0x2789e6
movq %rsp, %rsi
callq 0xeece0
movq %rsp, %rdi
callq 0xf9e00
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array.cpp
|
Omega_h::Write<signed char>::operator[](int) const
|
OMEGA_H_DEVICE T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return view_(i);
#else
return data()[i];
#endif
}
|
movslq %esi, %rax
addq 0x8(%rdi), %rax
retq
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::Write<signed char>::get(int) const
|
T Write<T>::get(LO i) const {
ScopedTimer timer("single device to host");
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK(0 <= i);
OMEGA_H_CHECK(i < size());
#endif
#ifdef OMEGA_H_USE_CUDA
T value;
cudaMemcpy(&value, data() + i, sizeof(T), cudaMemcpyDeviceToHost);
return value;
#else
return operator[](i);
#endif
}
|
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x15a612(%rip), %rdi # 0x278994
xorl %esi, %esi
callq 0xf9c20
movq 0x8(%r14), %rax
movslq %ebx, %rcx
movb (%rax,%rcx), %bl
leaq 0x7(%rsp), %rdi
callq 0xf7d50
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_array.cpp
|
Omega_h::Read<signed char>::Read(std::initializer_list<signed char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
Read<T>::Read(std::initializer_list<T> l, std::string const& name_in)
: Read<T>(HostWrite<T>(l, name_in).write()) {}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xf89e0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xfe060
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8e10
leaq 0x8(%rsp), %rdi
callq 0xf9e00
leaq 0x18(%rsp), %rdi
callq 0xf9e00
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf9e00
jmp 0x11e4e3
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array.cpp
|
Omega_h::Read<signed char>::size() const
|
const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic pop
#endif
}
#endif
return reinterpret_cast<std::uintptr_t>(alloc) >> 3;
}
|
movq (%rdi), %rax
testb $0x1, %al
jne 0x11e501
movq (%rax), %rax
retq
shrq $0x3, %rax
retq
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::Read<signed char>::last() const
|
const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic pop
#endif
}
#endif
return reinterpret_cast<std::uintptr_t>(alloc) >> 3;
}
|
movq (%rdi), %rsi
testb $0x1, %sil
jne 0x11e530
movq (%rsi), %rsi
jmp 0x11e534
shrq $0x3, %rsi
decl %esi
jmp 0x100580
nop
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::Read<signed char>::exists() const
|
OMEGA_H_INLINE bool exists() const noexcept {
#if defined(OMEGA_H_USE_KOKKOS)
return view().data() != nullptr
#if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && (!defined(__CUDA_ARCH__))
/* deprecated Kokkos behavior: zero-span views have data()==nullptr
*/
|| view().use_count() != 0
#endif
;
#else
return shared_alloc_.data() != nullptr;
#endif
}
|
cmpq $0x0, 0x8(%rdi)
setne %al
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::Read<signed char>::end() const
|
const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic pop
#endif
}
#endif
return reinterpret_cast<std::uintptr_t>(alloc) >> 3;
}
|
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testb $0x1, %cl
jne 0x11e573
movq (%rcx), %rcx
jmp 0x11e577
shrq $0x3, %rcx
movslq %ecx, %rcx
addq %rcx, %rax
retq
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::Write<signed char> Omega_h::deep_copy<signed char>(Omega_h::Read<signed char>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
Write<T> deep_copy(Read<T> a, std::string const& name) {
OMEGA_H_TIME_FUNCTION;
auto name2 = name.empty() ? a.name() : name;
Write<T> b(a.size(), name2);
copy_into(a, b);
return b;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x15a088(%rip), %rsi # 0x278a0a
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xef870
leaq 0x1588fd(%rip), %rdx # 0x277295
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xed920
leaq 0x50(%rsp), %rdi
movl $0x15a, %esi # imm = 0x15A
callq 0xf9ed0
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xf4ff0
movq 0x10(%rsp), %rsi
leaq 0x15a0b4(%rip), %rdi # 0x278a90
callq 0xf9c20
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0x50(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
callq 0xf00f0
leaq 0x70(%rsp), %rdi
callq 0xf00f0
cmpq $0x0, 0x8(%r15)
je 0x11ea22
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xfabe0
jmp 0x11ea2f
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0xf67a0
movq (%r14), %rsi
testb $0x1, %sil
jne 0x11ea3d
movq (%rsi), %rsi
jmp 0x11ea41
shrq $0x3, %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xf0f30
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xf8e10
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xf8e10
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xfc150
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x40(%rsp), %rdi
callq 0xf9e00
leaq 0x10(%rsp), %rdi
callq 0xf00f0
leaq 0xe(%rsp), %rdi
callq 0xf7d50
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xf9e00
jmp 0x11eac1
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x11ead0
movq %rax, %r14
movq %rbx, %rdi
callq 0xf9e00
jmp 0x11eadd
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x11eaec
movq %rax, %r14
leaq 0xe(%rsp), %rdi
callq 0xf7d50
jmp 0x11eb3a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xf00f0
jmp 0x11eb0a
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xf00f0
jmp 0x11eb19
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0xf00f0
jmp 0x11eb2b
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0xf00f0
jmp 0x11eb3a
movq %rax, %r14
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array.cpp
|
Omega_h::Write<int>::Write(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
Write<T>::Write(LO size_in, std::string const& name_in) {
begin_code("Write allocation");
#ifdef OMEGA_H_USE_KOKKOS
view_ = decltype(view_)(Kokkos::ViewAllocateWithoutInitializing(name_in),
static_cast<std::size_t>(size_in));
#else
shared_alloc_ = decltype(shared_alloc_)(
sizeof(T) * static_cast<std::size_t>(size_in), name_in);
#endif
end_code();
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x159dd6(%rip), %rdi # 0x27896d
xorl %esi, %esi
callq 0xf9c20
movslq %ebp, %rsi
shlq $0x2, %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0xf8970
movq (%rbx), %r14
testq %r14, %r14
sete %al
testb $0x7, %r14b
setne %cl
orb %al, %cl
jne 0x11ebdd
decl 0x30(%r14)
jne 0x11ebdd
movq %r14, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0xf6cf0
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rbx)
testq %rax, %rax
sete %cl
testb $0x7, %al
setne %dl
orb %cl, %dl
jne 0x11ec19
movq 0x1f30bd(%rip), %rcx # 0x311cc0
cmpb $0x1, (%rcx)
jne 0x11ec19
decl 0x30(%rax)
movq (%rax), %rax
leaq 0x1(,%rax,8), %rax
movq %rax, (%rbx)
callq 0xfb6a0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x11ec29
movq %rax, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
sete %al
testb $0x7, %bl
setne %cl
orb %al, %cl
jne 0x11ec57
decl 0x30(%rbx)
jne 0x11ec57
movq %rbx, %rdi
callq 0xeedf0
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0xf6cf0
movq %r14, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array.cpp
|
Omega_h::Write<int>::exists() const
|
OMEGA_H_INLINE bool exists() const noexcept {
#if defined(OMEGA_H_USE_KOKKOS)
return view().data() != nullptr
#if defined(KOKKOS_ENABLE_DEPRECATED_CODE) && (!defined(__CUDA_ARCH__))
/* deprecated Kokkos behavior: zero-span views have data()==nullptr
*/
|| view().use_count() != 0
#endif
;
#else
return shared_alloc_.data() != nullptr;
#endif
}
|
cmpq $0x0, 0x8(%rdi)
setne %al
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::Write<int>::end() const
|
const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic pop
#endif
}
#endif
return reinterpret_cast<std::uintptr_t>(alloc) >> 3;
}
|
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testb $0x1, %cl
jne 0x11efad
movq (%rcx), %rcx
jmp 0x11efb1
shrq $0x3, %rcx
shrq $0x2, %rcx
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rax
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::HostWrite<int>::HostWrite(Omega_h::Write<int>)
|
HostWrite<T>::HostWrite(Write<T> write_in)
: write_(write_in)
#ifdef OMEGA_H_USE_KOKKOS
,
mirror_(create_uninit_mirror_view(write_.view()))
#endif
{
#ifdef OMEGA_H_USE_KOKKOS
Kokkos::deep_copy(mirror_, write_.view());
#elif defined(OMEGA_H_USE_CUDA)
mirror_.reset(new T[std::size_t(write_.size())]);
auto const err = cudaMemcpy(mirror_.get(), write_.data(),
std::size_t(write_.size()) * sizeof(T), cudaMemcpyDeviceToHost);
OMEGA_H_CHECK(err == cudaSuccess);
#endif
}
|
jmp 0xf0580
nop
|
/gahansen[P]omega_h/src/Omega_h_array.cpp
|
Omega_h::HostWrite<int>::operator[](int) const
|
OMEGA_H_DEVICE T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return view_(i);
#else
return data()[i];
#endif
}
|
movslq %esi, %rax
shlq $0x2, %rax
addq 0x8(%rdi), %rax
retq
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::HostWrite<int>::size() const
|
const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic pop
#endif
}
#endif
return reinterpret_cast<std::uintptr_t>(alloc) >> 3;
}
|
movq (%rdi), %rax
testb $0x1, %al
jne 0x11f214
movq (%rax), %rax
jmp 0x11f218
shrq $0x3, %rax
shrq $0x2, %rax
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::HostRead<int>::operator[](int) const
|
OMEGA_H_DEVICE T& operator[](LO i) const OMEGA_H_NOEXCEPT {
#ifdef OMEGA_H_CHECK_BOUNDS
OMEGA_H_CHECK_OP(0, <=, i);
OMEGA_H_CHECK_OP(i, <, size());
#endif
#ifdef OMEGA_H_USE_KOKKOS
return view_(i);
#else
return data()[i];
#endif
}
|
movslq %esi, %rax
shlq $0x2, %rax
addq 0x8(%rdi), %rax
retq
|
/gahansen[P]omega_h/src/Omega_h_array.hpp
|
Omega_h::HostRead<int>::last() const
|
const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic pop
#endif
}
#endif
return reinterpret_cast<std::uintptr_t>(alloc) >> 3;
}
|
movq (%rdi), %rax
testb $0x1, %al
jne 0x11f2c6
movq (%rax), %rax
jmp 0x11f2ca
shrq $0x3, %rax
movq 0x8(%rdi), %rcx
shlq $0x1e, %rax
movabsq $-0x100000000, %rdx # imm = 0xFFFFFFFF00000000
addq %rax, %rdx
sarq $0x20, %rdx
movl (%rcx,%rdx,4), %eax
retq
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
Omega_h::divide_each_maybe_zero(Omega_h::Read<double>, Omega_h::Read<double>)
|
Reals divide_each_maybe_zero(Reals a, Reals b) {
if (b.size() == 0) {
OMEGA_H_CHECK(a.size() == 0);
return a;
}
auto width = divide_no_remainder(a.size(), b.size());
Write<Real> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) {
if (b[i] != 0.0) {
for (Int j = 0; j < width; ++j) {
c[i * width + j] = a[i * width + j] / b[i];
}
} else {
for (Int j = 0; j < width; ++j) {
OMEGA_H_CHECK(a[i * width + j] == 0.0);
c[i * width + j] = 0.0;
}
}
};
parallel_for(b.size(), f, "divide_maybe_zero");
return c;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
testb $0x1, %sil
jne 0x121c52
movq (%rsi), %rcx
jmp 0x121c59
movq %rsi, %rcx
shrq $0x3, %rcx
movabsq $0x7fffffff8, %rax # imm = 0x7FFFFFFF8
movq (%r14), %rdi
testq %rax, %rcx
je 0x121c76
testb $0x1, %dil
jne 0x121c88
movq (%rdi), %rdi
jmp 0x121c8c
testb $0x1, %dil
jne 0x121ebc
movq (%rdi), %rdi
jmp 0x121ec0
shrq $0x3, %rdi
shrq $0x3, %rdi
testb $0x1, %sil
jne 0x121c9b
movq (%rsi), %rsi
jmp 0x121c9f
shrq $0x3, %rsi
shrq $0x3, %rsi
callq 0xfd130
movl %eax, %ebp
movq (%r14), %r12
testb $0x1, %r12b
jne 0x121cb9
movq (%r12), %r12
jmp 0x121cbd
shrq $0x3, %r12
leaq 0x15b7f3(%rip), %rsi # 0x27d4b7
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xef870
shrq $0x3, %r12
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
movl %r12d, %esi
callq 0xf6560
leaq 0x20(%rsp), %rdi
callq 0xf00f0
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0xa8(%rsp), %r12
movl %ebp, -0x8(%r12)
movq %rsp, %rsi
movq %r12, %rdi
callq 0xf3e40
leaq 0xb8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xf3e40
movq (%r15), %rbp
testb $0x1, %bpl
jne 0x121d3b
movq (%rbp), %rbp
jmp 0x121d3f
shrq $0x3, %rbp
leaq 0x58(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xf3e40
movl 0xa0(%rsp), %eax
leaq 0x70(%rsp), %r14
movl %eax, -0x8(%r14)
movq %r14, %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xf3e40
shrq $0x3, %rbp
testl %ebp, %ebp
jle 0x121e77
movq 0x1eff2e(%rip), %r13 # 0x311cc0
movb $0x1, (%r13)
leaq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xfbcb0
movl 0x68(%rsp), %eax
leaq 0x38(%rsp), %r12
movl %eax, -0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0xfbcb0
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
callq 0xfbcb0
movb $0x0, (%r13)
movq 0x28(%rsp), %rax
movslq 0x30(%rsp), %rcx
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
andl $0x7fffffff, %ebp # imm = 0x7FFFFFFF
shlq $0x3, %rcx
xorpd %xmm0, %xmm0
xorl %edi, %edi
cmpq %rbp, %rdi
je 0x121e6d
movsd (%rax,%rdi,8), %xmm1
ucomisd %xmm0, %xmm1
movq 0x40(%rsp), %r8
movq 0x50(%rsp), %r9
jne 0x121e13
jnp 0x121e37
addq %rdx, %r8
addq %rdx, %r9
xorl %r10d, %r10d
cmpq %r10, %rsi
je 0x121e65
movsd (%r9,%r10,8), %xmm1
divsd (%rax,%rdi,8), %xmm1
movsd %xmm1, (%r8,%r10,8)
incq %r10
jmp 0x121e1c
addq %rdx, %r8
addq %rdx, %r9
xorl %r10d, %r10d
cmpq %r10, %rsi
je 0x121e65
movsd (%r9,%r10,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x121ee5
jp 0x121ee5
andq $0x0, (%r8,%r10,8)
incq %r10
jmp 0x121e40
incq %rdi
addq %rcx, %rdx
jmp 0x121df7
leaq 0x20(%rsp), %rdi
callq 0x121fe0
leaq 0x58(%rsp), %rdi
callq 0x121fe0
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0xfbcb0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x10(%rsp), %rdi
callq 0xfdc90
leaq 0x90(%rsp), %rdi
callq 0x121fe0
movq %rsp, %rdi
callq 0xfdc90
jmp 0x121ed0
shrq $0x3, %rdi
testq %rax, %rdi
jne 0x121f06
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfbcb0
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15519c(%rip), %rdi # 0x277088
leaq 0x156dd6(%rip), %rsi # 0x278cc9
leaq 0x156bd6(%rip), %rdx # 0x278ad0
movl $0x9b, %ecx
xorl %eax, %eax
callq 0xf6ee0
leaq 0x15517b(%rip), %rdi # 0x277088
leaq 0x156c20(%rip), %rsi # 0x278b34
leaq 0x156bb5(%rip), %rdx # 0x278ad0
movl $0x8f, %ecx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
movq %r12, %rdi
callq 0xfdc90
jmp 0x121f37
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xfdc90
jmp 0x121fb8
movq %rax, %rbx
jmp 0x121fb8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x121f67
movq %rax, %rbx
movq %r14, %rdi
callq 0xfdc90
jmp 0x121f62
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xfdc90
jmp 0x121fc2
movq %rax, %rbx
movq %r12, %rdi
callq 0xfdc90
jmp 0x121f7e
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xfdc90
jmp 0x121fcf
movq %rax, %rbx
jmp 0x121fcf
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf00f0
jmp 0x121fd7
movq %rax, %rbx
jmp 0x121fd7
movq %rax, %rbx
jmp 0x121fc2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x121fe0
leaq 0x58(%rsp), %rdi
callq 0x121fe0
leaq 0x90(%rsp), %rdi
callq 0x121fe0
movq %rsp, %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::land_each(Omega_h::Read<signed char>, Omega_h::Read<signed char>)
|
Bytes land_each(Bytes a, Bytes b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] && b[i]); };
parallel_for(c.size(), f, "land_each");
return c;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x122310
movq (%r12), %rax
jmp 0x122317
movq %r12, %rax
shrq $0x3, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x122324
movq (%rcx), %rcx
jmp 0x122328
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x1224cd
testb $0x1, %r12b
jne 0x12233c
movq (%r12), %r12
jmp 0x122340
shrq $0x3, %r12
leaq 0x15b170(%rip), %rsi # 0x27d4b7
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movl %r12d, %esi
callq 0xf0f30
leaq 0x28(%rsp), %rdi
callq 0xf00f0
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf8e10
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movq 0x8(%rsp), %r13
testb $0x1, %r13b
jne 0x1223bb
movq (%r13), %r13
jmp 0x1223bf
shrq $0x3, %r13
leaq 0x58(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xf8e10
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
testl %r13d, %r13d
jle 0x122471
movq 0x1ef8c3(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x100b80
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x100b80
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x100b80
movb $0x0, (%rbp)
andl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpq %rax, %r13
je 0x122467
movq 0x40(%rsp), %rcx
cmpb $0x0, (%rcx,%rax)
je 0x122458
movq 0x50(%rsp), %rcx
cmpb $0x0, (%rcx,%rax)
setne %cl
jmp 0x12245a
xorl %ecx, %ecx
movq 0x30(%rsp), %rdx
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x12243a
leaq 0x28(%rsp), %rdi
callq 0x12259a
leaq 0x58(%rsp), %rdi
callq 0x12259a
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x88(%rsp), %rdi
callq 0x12259a
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x154bb4(%rip), %rdi # 0x277088
leaq 0x15658f(%rip), %rsi # 0x278a6a
leaq 0x1565ee(%rip), %rdx # 0x278ad0
movl $0x161, %ecx # imm = 0x161
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
movq %r15, %rdi
callq 0xf9e00
jmp 0x1224fe
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf9e00
jmp 0x12250d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x12259a
jmp 0x12257a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x122538
movq %rax, %rbx
movq %r14, %rdi
callq 0xf9e00
jmp 0x122533
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf9e00
jmp 0x12257a
movq %rax, %rbx
movq %r12, %rdi
callq 0xf9e00
jmp 0x12254f
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf9e00
jmp 0x122587
movq %rax, %rbx
jmp 0x122587
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf00f0
jmp 0x122591
movq %rax, %rbx
jmp 0x122591
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x12259a
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::lor_each(Omega_h::Read<signed char>, Omega_h::Read<signed char>)
|
Bytes lor_each(Bytes a, Bytes b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] || b[i]); };
parallel_for(c.size(), f, "lor_each");
return c;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x1225e2
movq (%r12), %rax
jmp 0x1225e9
movq %r12, %rax
shrq $0x3, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1225f6
movq (%rcx), %rcx
jmp 0x1225fa
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x12279d
testb $0x1, %r12b
jne 0x12260e
movq (%r12), %r12
jmp 0x122612
shrq $0x3, %r12
leaq 0x15ae9e(%rip), %rsi # 0x27d4b7
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movl %r12d, %esi
callq 0xf0f30
leaq 0x28(%rsp), %rdi
callq 0xf00f0
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf8e10
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movq 0x8(%rsp), %r13
testb $0x1, %r13b
jne 0x12268d
movq (%r13), %r13
jmp 0x122691
shrq $0x3, %r13
leaq 0x58(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xf8e10
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
testl %r13d, %r13d
jle 0x122741
movq 0x1ef5f1(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x100b80
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x100b80
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x100b80
movb $0x0, (%rbp)
andl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpq %rax, %r13
je 0x122737
movq 0x40(%rsp), %rdx
movb $0x1, %cl
cmpb $0x0, (%rdx,%rax)
jne 0x12272a
movq 0x50(%rsp), %rcx
cmpb $0x0, (%rcx,%rax)
setne %cl
movq 0x30(%rsp), %rdx
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x12270c
leaq 0x28(%rsp), %rdi
callq 0x12286a
leaq 0x58(%rsp), %rdi
callq 0x12286a
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x88(%rsp), %rdi
callq 0x12286a
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1548e4(%rip), %rdi # 0x277088
leaq 0x1562bf(%rip), %rsi # 0x278a6a
leaq 0x15631e(%rip), %rdx # 0x278ad0
movl $0x169, %ecx # imm = 0x169
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
movq %r15, %rdi
callq 0xf9e00
jmp 0x1227ce
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf9e00
jmp 0x1227dd
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x12286a
jmp 0x12284a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x122808
movq %rax, %rbx
movq %r14, %rdi
callq 0xf9e00
jmp 0x122803
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf9e00
jmp 0x12284a
movq %rax, %rbx
movq %r12, %rdi
callq 0xf9e00
jmp 0x12281f
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf9e00
jmp 0x122857
movq %rax, %rbx
jmp 0x122857
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf00f0
jmp 0x122861
movq %rax, %rbx
jmp 0x122861
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x12286a
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::bit_or_each(Omega_h::Read<signed char>, Omega_h::Read<signed char>)
|
Bytes bit_or_each(Bytes a, Bytes b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] | b[i]); };
parallel_for(c.size(), f, "bit_or_each");
return c;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x1228b2
movq (%r12), %rax
jmp 0x1228b9
movq %r12, %rax
shrq $0x3, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1228c6
movq (%rcx), %rcx
jmp 0x1228ca
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x122a67
testb $0x1, %r12b
jne 0x1228de
movq (%r12), %r12
jmp 0x1228e2
shrq $0x3, %r12
leaq 0x15abce(%rip), %rsi # 0x27d4b7
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movl %r12d, %esi
callq 0xf0f30
leaq 0x28(%rsp), %rdi
callq 0xf00f0
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf8e10
leaq 0x98(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movq 0x8(%rsp), %r13
testb $0x1, %r13b
jne 0x12295d
movq (%r13), %r13
jmp 0x122961
shrq $0x3, %r13
leaq 0x58(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xf8e10
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0xf8e10
leaq 0x78(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
testl %r13d, %r13d
jle 0x122a0b
movq 0x1ef321(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x100b80
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x100b80
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x100b80
movb $0x0, (%rbp)
andl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpq %rax, %r13
je 0x122a01
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rdx
movq 0x50(%rsp), %rsi
movb (%rsi,%rax), %sil
orb (%rdx,%rax), %sil
movb %sil, (%rcx,%rax)
incq %rax
jmp 0x1229dc
leaq 0x28(%rsp), %rdi
callq 0x122b34
leaq 0x58(%rsp), %rdi
callq 0x122b34
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x88(%rsp), %rdi
callq 0x122b34
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15461a(%rip), %rdi # 0x277088
leaq 0x155ff5(%rip), %rsi # 0x278a6a
leaq 0x156054(%rip), %rdx # 0x278ad0
movl $0x171, %ecx # imm = 0x171
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
movq %r15, %rdi
callq 0xf9e00
jmp 0x122a98
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf9e00
jmp 0x122aa7
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x122b34
jmp 0x122b14
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x122ad2
movq %rax, %rbx
movq %r14, %rdi
callq 0xf9e00
jmp 0x122acd
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0xf9e00
jmp 0x122b14
movq %rax, %rbx
movq %r12, %rdi
callq 0xf9e00
jmp 0x122ae9
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xf9e00
jmp 0x122b21
movq %rax, %rbx
jmp 0x122b21
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf00f0
jmp 0x122b2b
movq %rax, %rbx
jmp 0x122b2b
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x122b34
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::bit_neg_each(Omega_h::Read<signed char>)
|
Bytes bit_neg_each(Bytes a) {
Write<I8> b(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = ~(a[i]); };
parallel_for(a.size(), f, "bit_neg_each");
return b;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testb $0x1, %r15b
jne 0x122b75
movq (%r15), %r15
jmp 0x122b79
shrq $0x3, %r15
leaq 0x15a937(%rip), %rsi # 0x27d4b7
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movl %r15d, %esi
callq 0xf0f30
leaq 0x18(%rsp), %rdi
callq 0xf00f0
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf8e10
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf8e10
movq (%r14), %r12
testb $0x1, %r12b
jne 0x122bd9
movq (%r12), %r12
jmp 0x122bdd
shrq $0x3, %r12
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xf8e10
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xf8e10
testl %r12d, %r12d
jle 0x122c5b
movq 0x1ef0b8(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x100b80
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x100b80
movb $0x0, (%r15)
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
xorl %eax, %eax
cmpq %rax, %r12
je 0x122c51
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
movb (%rdx,%rax), %dl
notb %dl
movb %dl, (%rcx,%rax)
incq %rax
jmp 0x122c35
leaq 0x18(%rsp), %rdi
callq 0x122d30
leaq 0x48(%rsp), %rdi
callq 0x122d30
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x38(%rsp), %rdi
callq 0xf9e00
leaq 0x68(%rsp), %rdi
callq 0x122d30
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf9e00
jmp 0x122cc3
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x122d30
jmp 0x122d13
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x122ce1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xf9e00
jmp 0x122d13
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xf9e00
jmp 0x122d1d
movq %rax, %rbx
jmp 0x122d1d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf00f0
jmp 0x122d27
movq %rax, %rbx
jmp 0x122d27
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x122d30
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::fabs_each(Omega_h::Read<double>)
|
Read<Real> fabs_each(Read<Real> a) {
Write<Real> b(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = std::abs(a[i]); };
parallel_for(a.size(), f, "fabs_each");
return b;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testb $0x1, %r15b
jne 0x122d68
movq (%r15), %r15
jmp 0x122d6c
shrq $0x3, %r15
leaq 0x15a744(%rip), %rsi # 0x27d4b7
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xef870
shrq $0x3, %r15
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movl %r15d, %esi
callq 0xf6560
leaq 0x18(%rsp), %rdi
callq 0xf00f0
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf3e40
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
movq (%r14), %r12
testb $0x1, %r12b
jne 0x122dd0
movq (%r12), %r12
jmp 0x122dd4
shrq $0x3, %r12
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xf3e40
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xf3e40
shrq $0x3, %r12
testl %r12d, %r12d
jle 0x122e61
movq 0x1eeebd(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xfbcb0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xfbcb0
movb $0x0, (%r15)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
xorl %edx, %edx
movaps 0x155c7f(%rip), %xmm0 # 0x278ac0
cmpq %rdx, %r12
je 0x122e57
movsd (%rcx,%rdx,8), %xmm1
andps %xmm0, %xmm1
movlps %xmm1, (%rax,%rdx,8)
incq %rdx
jmp 0x122e41
leaq 0x18(%rsp), %rdi
callq 0x122f36
leaq 0x48(%rsp), %rdi
callq 0x122f36
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xfbcb0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x38(%rsp), %rdi
callq 0xfdc90
leaq 0x68(%rsp), %rdi
callq 0x122f36
leaq 0x8(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xfdc90
jmp 0x122ec9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x122f36
jmp 0x122f19
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x122ee7
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xfdc90
jmp 0x122f19
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xfdc90
jmp 0x122f23
movq %rax, %rbx
jmp 0x122f23
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf00f0
jmp 0x122f2d
movq %rax, %rbx
jmp 0x122f2d
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x122f36
leaq 0x8(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::int128_sum(Omega_h::Read<double>, double)
|
Int128 int128_sum(Reals const a, double const unit) {
if (a.size() == 0) {
return Int128(0);
}
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = Int128(0);
auto const op = Int128Plus();
auto transform = OMEGA_H_LAMBDA(LO i)->Int128 {
return Int128::from_double(a[i], unit);
};
return transform_reduce(first, last, init, op, std::move(transform));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
movq (%rdi), %r14
testb $0x1, %r14b
jne 0x12306b
movq (%r14), %r14
movq %r14, %rax
shrq $0x3, %rax
testl %eax, %eax
jne 0x12307e
jmp 0x123112
movq %r14, %rax
shrq $0x6, %rax
testl %eax, %eax
je 0x123112
shrq $0x3, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xf3e40
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movq 0x1eec1d(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0xf3e40
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movb $0x0, (%r15)
movq 0x30(%rsp), %rax
shrq $0x3, %r14
movslq %r14d, %rcx
xorl %edx, %edx
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpq %rdx, %rcx
je 0x1230fc
movsd (%rax,%rdx,8), %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rdi
sarq $0x3f, %rdi
addq %rsi, %r14
adcq %rdi, %rbx
incq %rdx
jmp 0x1230d7
leaq 0x28(%rsp), %rdi
callq 0xfdc90
leaq 0x10(%rsp), %rdi
callq 0xfdc90
jmp 0x123117
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rbx, %rax
movq %r14, %rdx
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::repro_sum(Omega_h::Read<double>)
|
Real repro_sum(Reals a) {
if (a.size() == 0) {
return 0.0;
}
begin_code("repro_sum");
int expo = max_exponent(a);
auto const init = ArithTraits<int>::min();
if (expo == init) return 0.0;
double unit = exp2(double(expo - MANTISSA_BITS));
Int128 fixpt_sum = int128_sum(a, unit);
double ret = fixpt_sum.to_double(unit);
end_code();
return ret;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
testb $0x1, %al
jne 0x123153
movq (%rax), %rax
jmp 0x123157
shrq $0x3, %rax
shrq $0x3, %rax
xorps %xmm0, %xmm0
testl %eax, %eax
je 0x12320c
leaq 0x155b42(%rip), %rdi # 0x278caf
xorl %esi, %esi
callq 0xf9c20
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf3e40
movq %r14, %rdi
callq 0xef510
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0xfdc90
movl %ebp, %eax
negl %eax
xorps %xmm0, %xmm0
jo 0x12320c
addl $-0x34, %ebp
movsd 0x153e9c(%rip), %xmm0 # 0x277048
movl %ebp, %edi
callq 0xfc5f0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf3e40
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0xeeed0
leaq 0x30(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
leaq 0x10(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0xef6e0
movsd %xmm0, 0x8(%rsp)
callq 0xfb6a0
movsd 0x8(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x123227
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::repro_sum(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>)
|
Real repro_sum(CommPtr comm, Reals a) {
begin_code("repro_sum(comm)");
auto const init = ArithTraits<int>::min();
auto expo0 = max_exponent(a);
int expo = comm->allreduce(expo0, OMEGA_H_MAX);
if (expo == init) return 0.0;
double unit = exp2(double(expo - MANTISSA_BITS));
Int128 fixpt_sum = int128_sum(a, unit);
fixpt_sum = comm->add_int128(fixpt_sum);
double ret = fixpt_sum.to_double(unit);
end_code();
return ret;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x155a6e(%rip), %rdi # 0x278cb9
xorl %esi, %esi
callq 0xf9c20
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
movq %r15, %rdi
callq 0xef510
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0xfdc90
movq (%rbx), %rdi
pushq $0x1
popq %rdx
movl %ebp, %esi
callq 0xefb80
xorps %xmm0, %xmm0
movl %eax, %ecx
negl %ecx
jo 0x123303
addl $-0x34, %eax
movsd 0x153db1(%rip), %xmm0 # 0x277048
movl %eax, %edi
callq 0xfc5f0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
movq %r15, %rdi
movsd (%rsp), %xmm0
callq 0xeeed0
movq %rax, %r14
movq %rdx, %r15
leaq 0x8(%rsp), %rdi
callq 0xfdc90
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf4360
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movsd (%rsp), %xmm0
callq 0xef6e0
movsd %xmm0, (%rsp)
callq 0xfb6a0
movsd (%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x123320
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::repro_sum(std::shared_ptr<Omega_h::Comm>, Omega_h::Read<double>, int, double*)
|
void repro_sum(CommPtr comm, Reals a, Int ncomps, Real result[]) {
for (Int comp = 0; comp < ncomps; ++comp) {
result[comp] = repro_sum(comm, get_component(a, ncomps, comp));
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
xorl %r13d, %r13d
testl %edx, %edx
movl $0x0, %r12d
cmovgl %edx, %r12d
leaq 0x18(%rsp), %rbx
leaq 0x28(%rsp), %r14
leaq 0x38(%rsp), %r15
cmpq %r13, %r12
je 0x1233cc
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0xf21a0
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0xf3e40
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0xf3f30
movq %rbx, %rdi
movq %r15, %rsi
callq 0x101840
movq (%rsp), %rax
movsd %xmm0, (%rax,%r13,8)
movq %r15, %rdi
callq 0xfdc90
movq %r14, %rdi
callq 0xfdc90
leaq 0x20(%rsp), %rdi
callq 0xf6d50
incq %r13
jmp 0x123369
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1233fc
movq %rax, %rbx
jmp 0x1233f2
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xfdc90
leaq 0x28(%rsp), %rdi
callq 0xfdc90
leaq 0x20(%rsp), %rdi
callq 0xf6d50
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::interpolate_between(Omega_h::Read<double>, Omega_h::Read<double>, double)
|
Reals interpolate_between(Reals a, Reals b, Real t) {
OMEGA_H_CHECK(a.size() == b.size());
auto n = a.size();
auto out = Write<Real>(n);
auto f = OMEGA_H_LAMBDA(LO i) { out[i] = a[i] * (1.0 - t) + b[i] * t; };
parallel_for(n, f, "interpolate_between");
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movsd %xmm0, 0x18(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r14
testb $0x1, %r14b
jne 0x12343c
movq (%r14), %rax
jmp 0x123443
movq %r14, %rax
shrq $0x3, %rax
shrq $0x3, %rax
movq (%r15), %rcx
testb $0x1, %cl
jne 0x123454
movq (%rcx), %rcx
jmp 0x123458
shrq $0x3, %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x123634
testb $0x1, %r14b
jne 0x12346f
movq (%r14), %r14
jmp 0x123473
shrq $0x3, %r14
leaq 0x15a03d(%rip), %rsi # 0x27d4b7
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0xef870
shrq $0x3, %r14
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl %r14d, %esi
callq 0xf6560
leaq 0x30(%rsp), %rdi
callq 0xf00f0
leaq 0xa0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf3e40
leaq 0xb0(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xf3e40
leaq 0xc8(%rsp), %rbp
movsd 0x18(%rsp), %xmm0
movsd %xmm0, -0x8(%rbp)
movq %rbp, %rdi
movq %r15, %rsi
callq 0xf3e40
leaq 0x68(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xf3e40
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xf3e40
movsd 0xc0(%rsp), %xmm0
leaq 0x90(%rsp), %r12
movsd %xmm0, -0x8(%r12)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xf3e40
testl %r14d, %r14d
jle 0x1235d8
movq 0x1ee77f(%rip), %rbp # 0x311cc0
movb $0x1, (%rbp)
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xfbcb0
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xfbcb0
movsd 0x88(%rsp), %xmm0
leaq 0x58(%rsp), %rdi
movsd %xmm0, -0x8(%rdi)
movq %r12, %rsi
callq 0xfbcb0
movb $0x0, (%rbp)
movq 0x38(%rsp), %rax
movq 0x48(%rsp), %rcx
movq 0x60(%rsp), %rdx
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
xorl %esi, %esi
movsd 0x153aa5(%rip), %xmm0 # 0x277048
cmpq %rsi, %r14
je 0x1235ce
movsd 0x50(%rsp), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
mulsd (%rdx,%rsi,8), %xmm1
mulsd (%rcx,%rsi,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rax,%rsi,8)
incq %rsi
jmp 0x1235a3
leaq 0x30(%rsp), %rdi
callq 0x123700
leaq 0x68(%rsp), %rdi
callq 0x123700
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xfbcb0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xf6440
leaq 0x20(%rsp), %rdi
callq 0xfdc90
leaq 0xa0(%rsp), %rdi
callq 0x123700
leaq 0x8(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x153a4d(%rip), %rdi # 0x277088
leaq 0x155428(%rip), %rsi # 0x278a6a
leaq 0x155487(%rip), %rdx # 0x278ad0
movl $0x238, %ecx # imm = 0x238
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
movq %r13, %rdi
callq 0xfdc90
jmp 0x123665
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xfdc90
jmp 0x123674
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x123700
jmp 0x1236e1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x12369f
movq %rax, %rbx
movq %r15, %rdi
callq 0xfdc90
jmp 0x12369a
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xfdc90
jmp 0x1236e1
movq %rax, %rbx
movq %r13, %rdi
callq 0xfdc90
jmp 0x1236b6
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0xfdc90
jmp 0x1236ee
movq %rax, %rbx
jmp 0x1236ee
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xf00f0
jmp 0x1236f8
movq %rax, %rbx
jmp 0x1236f8
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x123700
leaq 0x8(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::Read<signed char> Omega_h::neq_each<signed char>(Omega_h::Read<signed char>, Omega_h::Read<signed char>)
|
Bytes neq_each(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
Write<I8> c(a.size());
auto f = OMEGA_H_LAMBDA(LO i) { c[i] = (a[i] != b[i]); };
parallel_for("neq_each", c.size(), std::move(f));
return c;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %r12
testb $0x1, %r12b
jne 0x126554
movq (%r12), %rax
jmp 0x12655b
movq %r12, %rax
shrq $0x3, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x126568
movq (%rcx), %rcx
jmp 0x12656c
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x126650
testb $0x1, %r12b
jne 0x126580
movq (%r12), %r12
jmp 0x126584
shrq $0x3, %r12
leaq 0x156f2c(%rip), %rsi # 0x27d4b7
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movl %r12d, %esi
callq 0xf0f30
leaq 0x28(%rsp), %rdi
callq 0xf00f0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf8e10
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xf8e10
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0xf8e10
movq 0x8(%rsp), %rdi
testb $0x1, %dil
jne 0x1265f2
movq (%rdi), %rdi
jmp 0x1265f6
shrq $0x3, %rdi
leaq 0x152639(%rip), %rdx # 0x278c36
leaq 0x28(%rsp), %rsi
callq 0xf59e0
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x18(%rsp), %rdi
callq 0xf9e00
leaq 0x28(%rsp), %rdi
callq 0xf9720
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x150a31(%rip), %rdi # 0x277088
leaq 0x15240c(%rip), %rsi # 0x278a6a
leaq 0x15246b(%rip), %rdx # 0x278ad0
movl $0x113, %ecx # imm = 0x113
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf9e00
jmp 0x1266b8
movq %rax, %rbx
movq %r12, %rdi
callq 0xf9e00
jmp 0x126690
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf9e00
jmp 0x1266c2
movq %rax, %rbx
jmp 0x1266c2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf00f0
jmp 0x1266cc
movq %rax, %rbx
jmp 0x1266cc
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf9720
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::Read<signed char> Omega_h::get_component<signed char>(Omega_h::Read<signed char>, int, int)
|
Read<T> get_component(Read<T> a, Int ncomps, Int comp) {
Write<T> b(divide_no_remainder(a.size(), ncomps));
auto f = OMEGA_H_LAMBDA(LO i) { b[i] = a[i * ncomps + comp]; };
parallel_for(b.size(), f, "get_component");
return b;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x126718
movq (%rdi), %rdi
jmp 0x12671c
shrq $0x3, %rdi
movl %r14d, %esi
callq 0xfd130
movl %eax, %r12d
leaq 0x156d89(%rip), %rsi # 0x27d4b7
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xef870
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
movl %r12d, %esi
callq 0xf0f30
leaq 0x18(%rsp), %rdi
callq 0xf00f0
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xf8e10
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0xf8e10
movl %r14d, 0x38(%rsp)
movl %ebp, 0x3c(%rsp)
movq 0x8(%rsp), %rdi
testb $0x1, %dil
jne 0x12678e
movq (%rdi), %rdi
jmp 0x126792
shrq $0x3, %rdi
leaq 0x1524a6(%rip), %rdx # 0x278c3f
leaq 0x18(%rsp), %rsi
callq 0xfd170
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xf8470
leaq 0x40(%rsp), %rdi
callq 0xf9e00
leaq 0x18(%rsp), %rdi
callq 0xf6a80
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x126827
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf9e00
jmp 0x126831
movq %rax, %rbx
jmp 0x126831
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf00f0
jmp 0x12683b
movq %rax, %rbx
jmp 0x12683b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf6a80
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
int Omega_h::find_last<signed char>(Omega_h::Read<signed char>, signed char)
|
LO find_last(Read<T> array, T value) {
auto const first = IntIterator(0);
auto const last = IntIterator(array.size());
auto const init = -1;
auto const op = maximum<LO>();
auto transform = OMEGA_H_LAMBDA(LO i)->LO {
if (array[i] == value)
return i;
else
return -1;
};
return transform_reduce(first, last, init, op, std::move(transform));
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x126998
movq (%rbx), %rbx
jmp 0x12699c
shrq $0x3, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf8e10
movb %bpl, 0x10(%r14)
pushq $-0x1
popq %rdx
xorl %edi, %edi
movl %ebx, %esi
movq %r14, %rcx
callq 0xffc80
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::Read<signed char> Omega_h::interleave<signed char>(std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>)
|
Read<T> interleave(std::vector<Read<T>> arrays) {
if (arrays.empty()) return Read<T>();
auto narrays = LO(arrays.size());
auto array_size = arrays.front().size();
for (auto& array : arrays) OMEGA_H_CHECK(array.size() == array_size);
auto out_size = narrays * array_size;
auto out = Write<T>(out_size);
for (LO i = 0; i < narrays; ++i) {
auto array = arrays[std::size_t(i)];
auto f = OMEGA_H_LAMBDA(LO j) { out[j * narrays + i] = array[j]; };
parallel_for(array_size, f, "interleave");
}
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, 0x28(%rsp)
movq 0x8(%rsi), %rcx
cmpq %rcx, %rax
je 0x126b7e
movq %rcx, %rbp
subq %rax, %rbp
shrq $0x4, %rbp
movq (%rax), %r15
testb $0x1, %r15b
jne 0x126b89
movq (%r15), %r15
jmp 0x126b8d
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x126cc4
shrq $0x3, %r15
cmpq %rcx, %rax
je 0x126bcd
movq (%rax), %rdx
testb $0x1, %dl
jne 0x126b9f
movq (%rdx), %rdx
jmp 0x126ba3
shrq $0x3, %rdx
addq $0x10, %rax
cmpl %r15d, %edx
je 0x126b8d
leaq 0x1504d5(%rip), %rdi # 0x277088
leaq 0x1520a1(%rip), %rsi # 0x278c5b
leaq 0x151f0f(%rip), %rdx # 0x278ad0
movl $0x1b3, %ecx # imm = 0x1B3
xorl %eax, %eax
callq 0xf6ee0
leaq 0x1568e3(%rip), %rsi # 0x27d4b7
leaq 0x40(%rsp), %rdi
leaq 0x68(%rsp), %rdx
callq 0xef870
movq %rbx, 0x18(%rsp)
movl %r15d, %esi
imull %ebp, %esi
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xf0f30
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0xf00f0
xorl %r13d, %r13d
testl %ebp, %ebp
movl $0x0, %r14d
movq %rbp, 0x20(%rsp)
cmovgl %ebp, %r14d
leaq 0x68(%rsp), %rbp
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x126c8f
movq 0x28(%rsp), %rax
movq (%rax), %rsi
addq %r13, %rsi
movq %rbp, %rdi
callq 0xf8e10
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0xf8e10
movq 0x20(%rsp), %rax
movl %eax, 0x50(%rsp)
movl %ebx, 0x54(%rsp)
leaq 0x58(%rsp), %rdi
movq %rbp, %rsi
callq 0xf8e10
movl %r15d, %edi
movq %r12, %rsi
leaq 0x152005(%rip), %rdx # 0x278c76
callq 0xf5400
movq %r12, %rdi
callq 0xfb8e0
movq %rbp, %rdi
callq 0xf9e00
incq %rbx
addq $0x10, %r13
jmp 0x126c25
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x100b80
leaq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0xf8470
leaq 0x30(%rsp), %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x126d21
jmp 0x126cf6
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf00f0
jmp 0x126d30
movq %rax, %rbx
jmp 0x126d30
movq %rax, %rbx
jmp 0x126d26
movq %rax, %rbx
jmp 0x126d1c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xf9e00
jmp 0x126d1c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xfb8e0
leaq 0x68(%rsp), %rdi
callq 0xf9e00
leaq 0x8(%rsp), %rdi
callq 0xf9e00
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
Omega_h::Read<signed char> Omega_h::coalesce<signed char>(std::vector<Omega_h::Read<signed char>, std::allocator<Omega_h::Read<signed char>>>)
|
Read<T> coalesce(std::vector<Read<T>> arrays) {
if (arrays.empty()) return Read<T>();
std::vector<LO> offsets(arrays.size() + 1);
OMEGA_H_CHECK(offsets.data() != nullptr);
offsets[0] = 0;
for (std::size_t i = 1; i <= arrays.size(); ++i) {
offsets[i] = offsets[i - 1] + arrays[i].size();
}
auto out_size = offsets[arrays.size()];
auto out = Write<T>(out_size);
for (std::size_t i = 0; i < arrays.size(); ++i) {
auto array = arrays[std::size_t(i)];
auto offset = offsets[i];
auto f = OMEGA_H_LAMBDA(LO j) { out[offset + j] = array[j]; };
parallel_for(array.size(), f, "coalesce");
}
return out;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, %rax
je 0x126f1f
subq %rax, %rsi
sarq $0x4, %rsi
incq %rsi
leaq 0x60(%rsp), %rbx
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0xee7f0
movq (%rbx), %rax
testq %rax, %rax
je 0x126f38
andl $0x0, (%rax)
movq (%r14), %rdx
movq 0x8(%r14), %rcx
subq %rdx, %rcx
sarq $0x4, %rcx
addq $0x10, %rdx
pushq $0x1
popq %rsi
cmpq %rcx, %rsi
ja 0x126e1d
movq (%rdx), %rdi
testb $0x1, %dil
jne 0x126e09
movq (%rdi), %rdi
jmp 0x126e0d
shrq $0x3, %rdi
addl -0x4(%rax,%rsi,4), %edi
movl %edi, (%rax,%rsi,4)
incq %rsi
addq $0x10, %rdx
jmp 0x126df6
movl (%rax,%rcx,4), %ebx
leaq 0x156690(%rip), %rsi # 0x27d4b7
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xef870
movq %r15, 0x10(%rsp)
movq %rsp, %rdi
leaq 0x38(%rsp), %rdx
movl %ebx, %esi
callq 0xf0f30
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0xf00f0
xorl %r12d, %r12d
leaq 0x28(%rsp), %r13
xorl %ebp, %ebp
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x4, %rax
cmpq %rax, %rbp
jae 0x126edf
addq %r12, %rsi
movq %r13, %rdi
callq 0xf8e10
movq 0x60(%rsp), %rax
movl (%rax,%rbp,4), %ebx
movq %r15, %rdi
movq %rsp, %rsi
callq 0xf8e10
movl %ebx, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
callq 0xf8e10
movq 0x28(%rsp), %rdi
testb $0x1, %dil
jne 0x126eb3
movq (%rdi), %rdi
jmp 0x126eb7
shrq $0x3, %rdi
movq %r15, %rsi
leaq 0x151dda(%rip), %rdx # 0x278c9b
callq 0xedec0
movq %r15, %rdi
callq 0xeffe0
movq %r13, %rdi
callq 0xf9e00
incq %rbp
addq $0x10, %r12
jmp 0x126e61
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x100b80
leaq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xf8470
leaq 0x18(%rsp), %rdi
callq 0xf9e00
movq %rsp, %rdi
callq 0xf9e00
leaq 0x60(%rsp), %rdi
callq 0xf8380
movq %rbx, %rax
jmp 0x126f29
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %r15, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x150149(%rip), %rdi # 0x277088
leaq 0x151d3b(%rip), %rsi # 0x278c81
leaq 0x151b83(%rip), %rdx # 0x278ad0
movl $0x1c2, %ecx # imm = 0x1C2
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x126fa6
jmp 0x126f99
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf00f0
jmp 0x126fb3
jmp 0x126f76
movq %rax, %rbx
jmp 0x126fb3
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xeffe0
jmp 0x126fa1
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xf9e00
jmp 0x126fa1
movq %rax, %rbx
jmp 0x126fab
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xf9e00
movq %rsp, %rdi
callq 0xf9e00
leaq 0x60(%rsp), %rdi
callq 0xf8380
movq %rbx, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
bool Omega_h::operator==<int>(Omega_h::Read<int>, Omega_h::Read<int>)
|
bool operator==(Read<T> a, Read<T> b) {
OMEGA_H_CHECK(a.size() == b.size());
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = true;
auto const op = logical_and<bool>();
auto transform = OMEGA_H_LAMBDA(LO i)->bool { return a[i] == b[i]; };
return transform_reduce(first, last, init, op, std::move(transform));
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x12708a
movq (%rbx), %rax
jmp 0x127091
movq %rbx, %rax
shrq $0x3, %rax
shrq $0x2, %rax
movq (%r14), %rcx
testb $0x1, %cl
jne 0x1270a2
movq (%rcx), %rcx
jmp 0x1270a6
shrq $0x3, %rcx
shrq $0x2, %rcx
cmpl %ecx, %eax
jne 0x1270fe
testb $0x1, %bl
jne 0x1270b8
movq (%rbx), %rbx
jmp 0x1270bc
shrq $0x3, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf0580
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xf0580
shrq $0x2, %rbx
pushq $0x1
popq %rdx
leaq 0x8(%rsp), %rcx
xorl %edi, %edi
movl %ebx, %esi
callq 0xef3e0
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xfa800
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x14ff83(%rip), %rdi # 0x277088
leaq 0x15195e(%rip), %rsi # 0x278a6a
leaq 0x1519bd(%rip), %rdx # 0x278ad0
pushq $0xd
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfa800
jmp 0x127139
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
bool Omega_h::transform_reduce<Omega_h::IntIterator, bool Omega_h::operator==<int>(Omega_h::Read<int>, Omega_h::Read<int>)::'lambda'(int), bool, Omega_h::logical_and<bool>>(int, int, bool, Omega_h::logical_and<bool>, bool Omega_h::operator==<int>(Omega_h::Read<int>, Omega_h::Read<int>)::'lambda'(int)&&)
|
Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first));
}
return init;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movq 0x1eab65(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xff3b0
movb $0x0, (%r12)
movq 0x8(%r15), %rax
movq 0x18(%r15), %rcx
movslq %r14d, %rdx
movslq %ebp, %rsi
cmpq %rdx, %rsi
je 0x127198
movl (%rcx,%rdx,4), %edi
cmpl %edi, (%rax,%rdx,4)
sete %dil
andb %dil, %bl
incq %rdx
jmp 0x127181
movq %rsp, %rdi
callq 0xfa800
andb $0x1, %bl
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_reduce.hpp
|
Omega_h::Promoted<int>::type Omega_h::get_sum<int>(Omega_h::Read<int>)
|
const noexcept {
#ifndef __CUDA_ARCH__
if (!(reinterpret_cast<std::uintptr_t>(alloc) & IN_PARALLEL)) {
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
return alloc->size;
#if defined(__GNUC__) && (__GNUC__ >= 7) && (!defined(__clang__))
#pragma GCC diagnostic pop
#endif
}
#endif
return reinterpret_cast<std::uintptr_t>(alloc) >> 3;
}
|
movq (%rdi), %rax
testb $0x1, %al
jne 0x1271d4
movq (%rax), %rax
jmp 0x1271d8
shrq $0x3, %rax
movq 0x8(%rdi), %rcx
shrq $0x2, %rax
movslq %eax, %rdx
movq 0x1eaad6(%rip), %rax # 0x311cc0
movb $0x0, (%rax)
shlq $0x2, %rdx
xorl %esi, %esi
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x127203
addl (%rcx,%rsi), %eax
addq $0x4, %rsi
jmp 0x1271f5
retq
|
/gahansen[P]omega_h/src/Omega_h_shared_alloc.hpp
|
int Omega_h::get_min<int>(Omega_h::Read<int>)
|
T get_min(Read<T> a) {
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = promoted_t<T>(ArithTraits<T>::max());
auto const op = minimum<promoted_t<T>>();
auto transform = OMEGA_H_LAMBDA(LO i)->promoted_t<T> {
return promoted_t<T>(a[i]);
};
auto const r = transform_reduce(first, last, init, op, std::move(transform));
return T(r); // see StandinTraits
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x12721b
movq (%rbx), %rbx
jmp 0x12721f
shrq $0x3, %rbx
shrq $0x2, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf0580
xorl %edi, %edi
movl %ebx, %esi
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
movq %r14, %rcx
callq 0xf3b50
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xff620
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
int Omega_h::transform_reduce<Omega_h::IntIterator, int Omega_h::get_min<int>(Omega_h::Read<int>)::'lambda'(int), int, Omega_h::minimum<int>>(int, int, int, Omega_h::minimum<int>, int Omega_h::get_min<int>(Omega_h::Read<int>)::'lambda'(int)&&)
|
Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first));
}
return init;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movq 0x1eaa3a(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xf4160
movb $0x0, (%r12)
movq 0x8(%r15), %rax
movslq %r14d, %rcx
movslq %ebp, %rdx
cmpq %rcx, %rdx
je 0x1272ba
movl (%rax,%rcx,4), %esi
cmpl %esi, %ebx
cmovgel %esi, %ebx
incq %rcx
jmp 0x1272a8
movq %rsp, %rdi
callq 0xff620
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_reduce.hpp
|
int Omega_h::get_max<int>(Omega_h::Read<int>)
|
T get_max(Read<T> a) {
auto const first = IntIterator(0);
auto const last = IntIterator(a.size());
auto const init = promoted_t<T>(ArithTraits<T>::min());
auto const op = maximum<promoted_t<T>>();
auto transform = OMEGA_H_LAMBDA(LO i)->promoted_t<T> {
return promoted_t<T>(a[i]);
};
auto const r = transform_reduce(first, last, init, op, std::move(transform));
return static_cast<T>(r); // see StandinTraits
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x1272e8
movq (%rbx), %rbx
jmp 0x1272ec
shrq $0x3, %rbx
shrq $0x2, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xf0580
xorl %edi, %edi
movl %ebx, %esi
movl $0x80000000, %edx # imm = 0x80000000
movq %r14, %rcx
callq 0x100610
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xff620
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xff620
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
int Omega_h::transform_reduce<Omega_h::IntIterator, int Omega_h::get_max<int>(Omega_h::Read<int>)::'lambda'(int), int, Omega_h::maximum<int>>(int, int, int, Omega_h::maximum<int>, int Omega_h::get_max<int>(Omega_h::Read<int>)::'lambda'(int)&&)
|
Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first));
}
return init;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movq 0x1ea96d(%rip), %r12 # 0x311cc0
movb $0x1, (%r12)
movq %rsp, %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xf4160
movb $0x0, (%r12)
movq 0x8(%r15), %rax
movslq %r14d, %rcx
movslq %ebp, %rdx
cmpq %rcx, %rdx
je 0x127387
movl (%rax,%rcx,4), %esi
cmpl %esi, %ebx
cmovlel %esi, %ebx
incq %rcx
jmp 0x127375
movq %rsp, %rdi
callq 0xff620
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_reduce.hpp
|
Omega_h::Write<int> Omega_h::multiply_each<int>(Omega_h::Read<int>, Omega_h::Read<int>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
Write<T> multiply_each(Read<T> a, Read<T> b, std::string const& name) {
Write<T> c(a.size(), name);
if (b.size() == 0) {
OMEGA_H_CHECK(a.size() == 0);
return c;
}
auto width = divide_no_remainder(a.size(), b.size());
auto f = OMEGA_H_LAMBDA(LO i) {
for (Int j = 0; j < width; ++j) {
c[i * width + j] = a[i * width + j] * b[i];
}
};
parallel_for(b.size(), f, "multiply_each");
return c;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
testb $0x1, %sil
jne 0x1275a1
movq (%rsi), %rsi
jmp 0x1275a5
shrq $0x3, %rsi
shrq $0x2, %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0xedf20
movq (%r14), %rsi
testb $0x1, %sil
jne 0x1275c2
movq (%rsi), %rcx
jmp 0x1275c9
movq %rsi, %rcx
shrq $0x3, %rcx
movabsq $0x3fffffffc, %rax # imm = 0x3FFFFFFFC
movq (%r15), %rdi
testq %rax, %rcx
je 0x1275e6
testb $0x1, %dil
jne 0x1275f8
movq (%rdi), %rdi
jmp 0x1275fc
testb $0x1, %dil
jne 0x12767d
movq (%rdi), %rdi
jmp 0x127681
shrq $0x3, %rdi
shrq $0x2, %rdi
testb $0x1, %sil
jne 0x12760b
movq (%rsi), %rsi
jmp 0x12760f
shrq $0x3, %rsi
shrq $0x2, %rsi
callq 0xfd130
leaq 0x10(%rsp), %r12
movl %eax, -0x8(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf0580
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xf0580
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0xf0580
movq (%r14), %rdi
testb $0x1, %dil
jne 0x127658
movq (%rdi), %rdi
jmp 0x12765c
shrq $0x3, %rdi
shrq $0x2, %rdi
leaq 0x1514db(%rip), %rdx # 0x278b42
leaq 0x8(%rsp), %rsi
callq 0xfc5e0
leaq 0x8(%rsp), %rdi
callq 0xf5350
jmp 0x127686
shrq $0x3, %rdi
testq %rax, %rdi
jne 0x127697
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x14f9ea(%rip), %rdi # 0x277088
leaq 0x15148f(%rip), %rsi # 0x278b34
leaq 0x151424(%rip), %rdx # 0x278ad0
pushq $0x6b
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
jmp 0x1276e3
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xf5350
jmp 0x1276e6
movq %rax, %r14
movq %r13, %rdi
callq 0xff620
jmp 0x1276d7
movq %rax, %r14
movq %r12, %rdi
callq 0xff620
jmp 0x1276e6
jmp 0x1276e3
movq %rax, %r14
movq %rbx, %rdi
callq 0xff620
movq %r14, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_array_ops.cpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::neq_each<int>(Omega_h::Read<int>, Omega_h::Read<int>)::'lambda'(int)>(int, int, Omega_h::Read<signed char> Omega_h::neq_each<int>(Omega_h::Read<int>, Omega_h::Read<int>)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x13528d
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1dca7f(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x1015e0
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x13527d
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rsi
movl (%rsi,%rax,4), %esi
movq 0x28(%rsp), %rdi
cmpl (%rdi,%rax,4), %esi
setne (%rdx,%rax)
incq %rax
jmp 0x13525a
movq %rsp, %rdi
callq 0xfc550
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<int> Omega_h::get_component<int>(Omega_h::Read<int>, int, int)::'lambda'(int)>(int, int, Omega_h::Read<int> Omega_h::get_component<int>(Omega_h::Read<int>, int, int)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x1353ab
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x1dc980(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xfaac0
movb $0x0, (%r15)
movq 0x18(%r14), %rax
movslq %ebx, %rcx
movslq %ebp, %rdx
subq %rcx, %rdx
shlq $0x2, %rcx
addq 0x8(%r14), %rcx
movl %ebx, %esi
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x135399
movslq 0x20(%rsp), %r8
leal (%rsi,%rdi), %r9d
movslq %r9d, %r9
imulq %r8, %r9
movslq 0x24(%rsp), %r8
addq %r9, %r8
movl (%rax,%r8,4), %r8d
movl %r8d, (%rcx,%rdi,4)
incq %rdi
jmp 0x13536f
movq %rsp, %rdi
callq 0xef990
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::set_component<int>(Omega_h::Write<int>, Omega_h::Read<int>, int, int)::'lambda'(int)>(int, int, void Omega_h::set_component<int>(Omega_h::Write<int>, Omega_h::Read<int>, int, int)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x1354b6
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x1dc875(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf0ed0
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movslq %ebx, %rcx
movslq %ebp, %rdx
subq %rcx, %rdx
movl %ebx, %esi
shlq $0x2, %rcx
addq 0x20(%r14), %rcx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x1354a4
movl (%rcx,%rdi,4), %r8d
movslq 0x10(%rsp), %r9
leal (%rsi,%rdi), %r10d
movslq %r10d, %r10
imulq %r9, %r10
movslq 0x14(%rsp), %r9
addq %r10, %r9
movl %r8d, (%rax,%r9,4)
incq %rdi
jmp 0x13547a
movq %rsp, %rdi
callq 0xf80e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<int> Omega_h::interleave<int>(std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>)::'lambda'(int)>(int, int, Omega_h::Read<int> Omega_h::interleave<int>(std::vector<Omega_h::Read<int>, std::allocator<Omega_h::Read<int>>>)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x1355e2
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x1dc749(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xee100
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movslq %ebx, %rcx
movslq %ebp, %rdx
subq %rcx, %rdx
movl %ebx, %esi
shlq $0x2, %rcx
addq 0x20(%r14), %rcx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x1355d0
movl (%rcx,%rdi,4), %r8d
movslq 0x10(%rsp), %r9
leal (%rsi,%rdi), %r10d
movslq %r10d, %r10
imulq %r9, %r10
movslq 0x14(%rsp), %r9
addq %r10, %r9
movl %r8d, (%rax,%r9,4)
incq %rdi
jmp 0x1355a6
movq %rsp, %rdi
callq 0x100350
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::min_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::min_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x135f06
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1dbe15(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xfca90
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x28(%r14), %rdx
movslq %ebp, %rsi
movslq %ebx, %rdi
cmpq %rsi, %rdi
je 0x135ef2
movq (%rcx,%rsi,8), %r8
movq (%rdx,%rsi,8), %r9
cmpq %r8, %r9
cmovlq %r9, %r8
movq %r8, (%rax,%rsi,8)
incq %rsi
jmp 0x135ed5
leaq 0x8(%rsp), %rdi
callq 0xf2c20
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::max_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::max_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x136028
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1dbcf3(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xf7300
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movq 0x18(%r14), %rcx
movq 0x28(%r14), %rdx
movslq %ebp, %rsi
movslq %ebx, %rdi
cmpq %rsi, %rdi
je 0x136014
movq (%rcx,%rsi,8), %r8
movq (%rdx,%rsi,8), %r9
cmpq %r9, %r8
cmovgq %r8, %r9
movq %r9, (%rax,%rsi,8)
incq %rsi
jmp 0x135ff7
leaq 0x8(%rsp), %rdi
callq 0xf9960
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::ternary_each<long>(Omega_h::Read<signed char>, Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::ternary_each<long>(Omega_h::Read<signed char>, Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x136184
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movl %edi, %r14d
movq 0x1dbba3(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
movq %rsp, %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xf3e90
movb $0x0, (%r15)
movl 0x20(%rsp), %esi
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %r8
movslq %r14d, %rcx
movslq %ebp, %r9
cmpq %rcx, %r9
je 0x136172
movl %ecx, %eax
cltd
idivl %esi
cltq
xorl %edx, %edx
cmpb $0x0, (%r8,%rax)
sete %dl
shll $0x4, %edx
movq 0x30(%rdx,%rbx), %rax
movq (%rax,%rcx,8), %rax
movq %rax, (%rdi,%rcx,8)
incq %rcx
jmp 0x136147
movq %rsp, %rdi
callq 0xf8250
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_geq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)>(long, long, Omega_h::Read<signed char> Omega_h::each_geq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x136568
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1db7a6(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xf72e0
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x136556
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq (%rsi,%rax,8), %rsi
cmpq 0x28(%rsp), %rsi
setge (%rdx,%rax)
incq %rax
jmp 0x136535
leaq 0x8(%rsp), %rdi
callq 0xec290
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_leq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)>(long, long, Omega_h::Read<signed char> Omega_h::each_leq_to<long>(Omega_h::Read<long>, long)::'lambda'(int)&&)
|
OMEGA_H_INLINE bool operator>=(IntIterator const& other) const noexcept {
return i >= other.i;
}
|
cmpl %esi, %edi
jge 0x13664e
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movl %edi, %ebp
movq 0x1db6c0(%rip), %r14 # 0x311cc0
movb $0x1, (%r14)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0xf3350
movb $0x0, (%r14)
movslq %ebp, %rax
movslq %ebx, %rcx
cmpq %rax, %rcx
je 0x13663c
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq (%rsi,%rax,8), %rsi
cmpq 0x28(%rsp), %rsi
setle (%rdx,%rax)
incq %rax
jmp 0x13661b
leaq 0x8(%rsp), %rdi
callq 0xf7220
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/gahansen[P]omega_h/src/Omega_h_int_iterator.hpp
|
Omega_h::base64::(anonymous namespace)::decode_4(char const*, unsigned char*, unsigned long)
|
void decode_4(char const* in, unsigned char* out, std::size_t nout = 3) {
unsigned char val[4];
for (unsigned i = 0; i < 4; ++i) {
val[i] = char_to_value[U(in[i])];
OMEGA_H_CHECK(val[i] < 64);
}
/* cast it all !
* (technically this should all be run as
* unsigned char, but apparently it gets pushed
* up to int if we try that, so run it all as unsigned
* and cast back which we know is safe) */
out[0] =
UC(((U(val[0]) << U(2)) & U(0xFC)) | ((U(val[1]) >> U(4)) & U(0x03)));
if (nout < 2) return;
out[1] =
UC(((U(val[1]) << U(4)) & U(0xF0)) | ((U(val[2]) >> U(2)) & U(0x0F)));
if (nout < 3) return;
out[2] =
UC(((U(val[2]) << U(6)) & U(0xC0)) | ((U(val[3]) >> U(0)) & U(0x3F)));
}
|
pushq %rax
xorl %eax, %eax
leaq 0x13dd0e(%rip), %rcx # 0x278e20
cmpq $0x4, %rax
je 0x13b151
movsbq (%rdi,%rax), %r8
movl %r8d, %r8d
movb (%r8,%rcx), %r8b
movb %r8b, 0x4(%rsp,%rax)
incq %rax
cmpb $0x40, %r8b
jb 0x13b112
leaq 0x13bf4f(%rip), %rdi # 0x277088
leaq 0x13de20(%rip), %rsi # 0x278f60
leaq 0x13de25(%rip), %rdx # 0x278f6c
pushq $0x4b
popq %rcx
xorl %eax, %eax
callq 0xf6ee0
movb 0x4(%rsp), %cl
movb 0x5(%rsp), %al
shlb $0x2, %cl
movl %eax, %edi
shrb $0x4, %dil
andb $0x3, %dil
orb %cl, %dil
movb %dil, (%rsi)
cmpq $0x2, %rdx
jb 0x13b19e
shlb $0x4, %al
movb 0x6(%rsp), %cl
movl %ecx, %edi
shrb $0x2, %dil
andb $0xf, %dil
orb %al, %dil
movb %dil, 0x1(%rsi)
cmpq $0x2, %rdx
je 0x13b19e
shlb $0x6, %cl
movb 0x7(%rsp), %al
andb $0x3f, %al
orb %cl, %al
movb %al, 0x2(%rsi)
popq %rax
retq
|
/gahansen[P]omega_h/src/Omega_h_base64.cpp
|
Omega_h::base64::read_encoded[abi:cxx11](std::istream&)
|
std::string read_encoded(std::istream& f) {
std::string out;
while (true) {
int c = f.get();
if (c < 0 || c > 127) break;
unsigned char val = char_to_value[c];
if (val > 63) break;
out.push_back(static_cast<char>(c));
}
return out;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
leaq 0x13dc5e(%rip), %r15 # 0x278e20
movq %r14, %rdi
callq 0xf8c00
cmpl $0x7f, %eax
ja 0x13b1e5
movl %eax, %ecx
cmpb $0x3f, (%rcx,%r15)
ja 0x13b1e5
movsbl %al, %esi
movq %rbx, %rdi
callq 0xf5040
jmp 0x13b1c2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13b1f0
movq %rax, %r14
movq %rbx, %rdi
callq 0xf00f0
movq %r14, %rdi
callq 0xff4a0
nop
|
/gahansen[P]omega_h/src/Omega_h_base64.cpp
|
Omega_h::BBox<1> Omega_h::find_bounding_box<1>(Omega_h::Read<double>)
|
BBox<dim> find_bounding_box(Reals coords) {
auto npts = divide_no_remainder(coords.size(), dim);
BBox<dim> init;
for (Int i = 0; i < dim; ++i) {
init.min[i] = ArithTraits<Real>::max();
init.max[i] = ArithTraits<Real>::min();
}
return transform_reduce(IntIterator(0), IntIterator(npts), init,
UniteOp<dim>(), GetBBoxOp<dim>(coords));
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rsi
movq (%rdi), %rbx
testb $0x1, %bl
jne 0x13b21b
movq (%rbx), %rbx
jmp 0x13b21f
shrq $0x3, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xf3e40
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xf3e40
shrq $0x3, %rbx
movsd 0x13d86b(%rip), %xmm0 # 0x278ab0
movsd 0x13d86b(%rip), %xmm1 # 0x278ab8
leaq 0x18(%rsp), %rdx
xorl %edi, %edi
movl %ebx, %esi
callq 0xf8d50
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xfdc90
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xfdc90
jmp 0x13b2a1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_bbox.cpp
|
Omega_h::BBox<1> Omega_h::transform_reduce<Omega_h::IntIterator, Omega_h::GetBBoxOp<1>, Omega_h::BBox<1>, Omega_h::UniteOp<1>>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::BBox<1>, Omega_h::UniteOp<1>, Omega_h::GetBBoxOp<1>&&)
|
Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first));
}
return init;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movl %edi, %ebp
movq 0x1d69ec(%rip), %r15 # 0x311cc0
movb $0x1, (%r15)
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0xfbcb0
movsd 0x8(%rsp), %xmm3
movsd 0x10(%rsp), %xmm2
movb $0x0, (%r15)
movq 0x8(%r14), %rax
movslq %ebp, %rcx
movslq %ebx, %rdx
cmpq %rcx, %rdx
je 0x13b325
movsd (%rax,%rcx,8), %xmm0
movapd %xmm0, %xmm1
minsd %xmm3, %xmm1
maxsd %xmm2, %xmm0
incq %rcx
movapd %xmm1, %xmm3
movapd %xmm0, %xmm2
jmp 0x13b302
leaq 0x18(%rsp), %rdi
movsd %xmm2, 0x10(%rsp)
movsd %xmm3, 0x8(%rsp)
callq 0xfdc90
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_reduce.hpp
|
Omega_h::BBox<2> Omega_h::find_bounding_box<2>(Omega_h::Read<double>)
|
BBox<dim> find_bounding_box(Reals coords) {
auto npts = divide_no_remainder(coords.size(), dim);
BBox<dim> init;
for (Int i = 0; i < dim; ++i) {
init.min[i] = ArithTraits<Real>::max();
init.max[i] = ArithTraits<Real>::min();
}
return transform_reduce(IntIterator(0), IntIterator(npts), init,
UniteOp<dim>(), GetBBoxOp<dim>(coords));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x13b373
movq (%rdi), %rdi
jmp 0x13b377
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x2
popq %rsi
callq 0xfd130
movl %eax, %ebp
pushq $0x2
popq %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movabsq $-0x10000000000001, %rdx # imm = 0xFFEFFFFFFFFFFFFF
cmpq $0x4, %rax
je 0x13b3b1
movq %rcx, 0x58(%rsp,%rax,8)
movq %rdx, 0x68(%rsp,%rax,8)
incq %rax
jmp 0x13b39c
movups 0x68(%rsp), %xmm0
movups 0x78(%rsp), %xmm1
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rcx
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xf6e90
leaq 0x20(%rsp), %rdi
callq 0xfdc90
leaq 0x30(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xfdc90
jmp 0x13b43d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_bbox.cpp
|
Omega_h::BBox<2> Omega_h::transform_reduce<Omega_h::IntIterator, Omega_h::GetBBoxOp<2>, Omega_h::BBox<2>, Omega_h::UniteOp<2>>(Omega_h::IntIterator, Omega_h::IntIterator, Omega_h::BBox<2>, Omega_h::UniteOp<2>, Omega_h::GetBBoxOp<2>&&)
|
Result transform_reduce(
Iterator first, Iterator last, Result init, Op op, Tranform&& transform) {
Omega_h::entering_parallel = true;
auto const transform_local = std::move(transform);
Omega_h::entering_parallel = false;
for (; first != last; ++first) {
init = op(std::move(init), transform_local(*first));
}
return init;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xb0(%rsp), %r12
movq 0x1d684c(%rip), %r13 # 0x311cc0
movb $0x1, (%r13)
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
callq 0xfbcb0
movb $0x0, (%r13)
movslq %r14d, %rax
movslq %ebp, %rcx
movq %rax, %rdx
shlq $0x4, %rdx
addq 0x8(%r15), %rdx
pushq $0x2
popq %rsi
cmpq %rcx, %rax
je 0x13b53a
xorl %edi, %edi
cmpq $0x2, %rdi
je 0x13b4c2
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsp,%rdi,8)
incq %rdi
jmp 0x13b4ad
movaps (%rsp), %xmm0
movups (%r12), %xmm1
movups 0x10(%r12), %xmm2
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsi, %rdi
cmpq $0x4, %rdi
je 0x13b515
movsd -0x10(%rsp,%rdi,8), %xmm0
movsd (%rsp,%rdi,8), %xmm1
minsd 0x10(%rsp,%rdi,8), %xmm0
movsd %xmm0, 0x38(%rsp,%rdi,8)
maxsd 0x20(%rsp,%rdi,8), %xmm1
movsd %xmm1, 0x48(%rsp,%rdi,8)
incq %rdi
jmp 0x13b4e7
movupd 0x48(%rsp), %xmm0
movupd 0x58(%rsp), %xmm1
movupd %xmm1, 0x10(%r12)
movupd %xmm0, (%r12)
incq %rax
addq $0x10, %rdx
jmp 0x13b4a2
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x68(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/gahansen[P]omega_h/src/Omega_h_reduce.hpp
|
Omega_h::BBox<3> Omega_h::find_bounding_box<3>(Omega_h::Read<double>)
|
BBox<dim> find_bounding_box(Reals coords) {
auto npts = divide_no_remainder(coords.size(), dim);
BBox<dim> init;
for (Int i = 0; i < dim; ++i) {
init.min[i] = ArithTraits<Real>::max();
init.max[i] = ArithTraits<Real>::min();
}
return transform_reduce(IntIterator(0), IntIterator(npts), init,
UniteOp<dim>(), GetBBoxOp<dim>(coords));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testb $0x1, %dil
jne 0x13b589
movq (%rdi), %rdi
jmp 0x13b58d
shrq $0x3, %rdi
shrq $0x3, %rdi
pushq $0x3
popq %rsi
callq 0xfd130
movl %eax, %ebp
xorl %eax, %eax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
movabsq $-0x10000000000001, %rdx # imm = 0xFFEFFFFFFFFFFFFF
cmpq $0x3, %rax
je 0x13b5cc
movq %rcx, 0x88(%rsp,%rax,8)
movq %rdx, 0xa0(%rsp,%rax,8)
incq %rax
jmp 0x13b5b1
movups 0x88(%rsp), %xmm0
movups 0x98(%rsp), %xmm1
movups 0xa8(%rsp), %xmm2
movaps %xmm2, 0x70(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf3e40
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0xf3e40
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movaps 0x70(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x30(%rsp), %rcx
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xf8490
leaq 0x30(%rsp), %rdi
callq 0xfdc90
leaq 0x40(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xfdc90
jmp 0x13b675
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xfdc90
movq %rbx, %rdi
callq 0xff4a0
|
/gahansen[P]omega_h/src/Omega_h_bbox.cpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.