name string | code string | asm string | file string |
|---|---|---|---|
updateNormalHints | static void updateNormalHints(_GLFWwindow* window, int width, int height)
{
XSizeHints* hints = XAllocSizeHints();
if (!window->monitor)
{
if (window->resizable)
{
if (window->minwidth != GLFW_DONT_CARE &&
window->minheight != GLFW_DONT_CARE)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
callq 0x13850
movq %rax, %rbx
cmpq $0x0, 0x40(%r14)
jne 0x2071c
cmpl $0x0, 0x8(%r14)
je 0x206fc
movl 0x50(%r14), %eax
cmpl $-0x1, %eax
je 0x206bb
movl 0x54(%r14), %ecx
cmpl $-0x1, %ecx
je 0x206bb
orb $0x10, (%rbx)
mo... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
sendEventToWM | static void sendEventToWM(_GLFWwindow* window, Atom type,
long a, long b, long c, long d, long e)
{
XEvent event;
memset(&event, 0, sizeof(event));
event.type = ClientMessage;
event.xclient.window = window->x11.handle;
event.xclient.format = 32; // Data is 32-bit longs
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x8(%rsp), %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x130d0
movl $0x21, (%rbx)
movq 0x340(%rbp), %rax
movq %rax, 0x20... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformIconifyWindow | void _glfwPlatformIconifyWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification ... | cmpl $0x0, 0x350(%rdi)
je 0x20a7e
leaq 0x26a47(%rip), %rsi # 0x474b9
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x17839
pushq %rbx
leaq 0x31df2(%rip), %rbx # 0x52878
movq 0x1feb8(%rbx), %rax
movq 0x340(%rdi), %rsi
movl 0x1fec0(%rbx), %edx
movq %rax, %rdi
callq 0x132b0
movq 0x1feb8(%rbx), %... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
waitForVisibilityNotify | static GLFWbool waitForVisibilityNotify(_GLFWwindow* window)
{
XEvent dummy;
double timeout = 0.1;
while (!XCheckTypedWindowEvent(_glfw.x11.display,
window->x11.handle,
VisibilityNotify,
&dummy))
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x31cd8(%rip), %r13 # 0x52878
pushq $0xf
popq %r15
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rbp
movq 0x1feb8(%r13), %rdi... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformMaximizeWindow | void _glfwPlatformMaximizeWindow(_GLFWwindow* window)
{
if (_glfw.x11.NET_WM_STATE &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT &&
_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
... | pushq %rbx
leaq 0x31c85(%rip), %rbx # 0x52878
movq 0x20438(%rbx), %rsi
movq 0x20450(%rbx), %rcx
testq %rsi, %rsi
setne %al
testq %rcx, %rcx
setne %dl
andb %al, %dl
movq 0x20458(%rbx), %r8
testq %r8, %r8
setne %al
andb %dl, %al
cmpb $0x1, %al
jne 0x20c3a
pushq $0x1
popq %rdx
movq %rdx, %r9
callq 0x20960
movq 0x1feb8... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformFocusWindow | void _glfwPlatformFocusWindow(_GLFWwindow* window)
{
if (_glfw.x11.NET_ACTIVE_WINDOW)
sendEventToWM(window, _glfw.x11.NET_ACTIVE_WINDOW, 1, 0, 0, 0, 0);
else
{
XRaiseWindow(_glfw.x11.display, window->x11.handle);
XSetInputFocus(_glfw.x11.display, window->x11.handle,
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x31be0(%rip), %r14 # 0x52878
movq 0x20488(%r14), %rsi
testq %rsi, %rsi
je 0x20cb9
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x20960
jmp 0x20ce4
movq 0x1feb8(%r14), %rdi
movq 0x340(%rbx), %rsi
callq 0x131e0
movq 0... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformWindowMaximized | int _glfwPlatformWindowMaximized(_GLFWwindow* window)
{
Atom* states;
unsigned long i;
GLFWbool maximized = GLFW_FALSE;
const unsigned long count =
_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_STATE,
XA_ATOM,
... | pushq %r14
pushq %rbx
pushq %rax
movq 0x340(%rdi), %rdi
leaq 0x319c6(%rip), %r14 # 0x52878
movq 0x20438(%r14), %rsi
pushq $0x4
popq %rdx
movq %rsp, %rbx
movq %rbx, %rcx
callq 0x1f2b0
movq (%rbx), %rdi
movq 0x20450(%r14), %rcx
movq 0x20458(%r14), %rdx
xorl %esi, %esi
pushq $0x1
popq %rbx
cmpq %rsi, %rax
je 0x20ef5
m... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformGetWindowOpacity | float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
{
float opacity = 1.f;
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx))
{
CARD32* value = NULL;
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_WINDOW_OPACITY... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3169a(%rip), %r15 # 0x52878
movq 0x1feb8(%r15), %rdi
movq 0x20480(%r15), %rsi
callq 0x13940
testq %rax, %rax
je 0x21235
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq 0x340(%rbx), %rdi
movq 0x20478(%r15), %rsi
pushq $0x6
popq %rdx
movq %r14, %rcx... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformSetCursorPos | void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
{
// Store the new position so it can be recognized later
window->x11.warpCursorPosX = (int) x;
window->x11.warpCursorPosY = (int) y;
XWarpPointer(_glfw.x11.display, None, window->x11.handle,
0,0,0,0, (int) x, (int... | pushq %rbx
subq $0x20, %rsp
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
cvttpd2dq %xmm0, %xmm0
movlpd %xmm0, 0x378(%rdi)
leaq 0x306ea(%rip), %rbx # 0x52878
movq 0x1feb8(%rbx), %rax
movq 0x340(%rdi), %rdx
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
andl $0x0, (%rsp)
movd %xmm1, 0x10(%rsp)
mov... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwKeySym2Unicode | long _glfwKeySym2Unicode(unsigned int keysym)
{
int min = 0;
int max = sizeof(keysymtab) / sizeof(struct codepair) - 1;
int mid;
// First check for Latin-1 characters (1:1 mapping)
if ((keysym >= 0x0020 && keysym <= 0x007e) ||
(keysym >= 0x00a0 && keysym <= 0x00ff))
{
return key... | leal -0x20(%rdi), %eax
cmpl $0x5f, %eax
setae %al
leal -0xa0(%rdi), %ecx
cmpl $0x60, %ecx
setae %cl
testb %cl, %al
jne 0x22f21
movl %edi, %ecx
jmp 0x22f80
movl %edi, %eax
andl $0xff000000, %eax # imm = 0xFF000000
cmpl $0x1000000, %eax # imm = 0x1000000
jne 0x22f3a
andl $0xffffff, %edi # imm = 0xFFF... | /Konf[P]LearnOpenGL-CLion/glfw/src/xkb_unicode.c |
glfwInitTimerPOSIX | void _glfwInitTimerPOSIX(void)
{
#if defined(CLOCK_MONOTONIC)
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
{
_glfw.timer.posix.monotonic = GLFW_TRUE;
_glfw.timer.posix.frequency = 1000000000;
}
else
#endif
{
_glfw.timer.posix.monotonic = GLFW_FALSE;
... | subq $0x18, %rsp
pushq $0x1
popq %rdi
leaq 0x8(%rsp), %rsi
callq 0x13130
xorl %ecx, %ecx
testl %eax, %eax
movl $0x3b9aca00, %eax # imm = 0x3B9ACA00
movl $0xf4240, %edx # imm = 0xF4240
cmoveq %rax, %rdx
sete %cl
leaq 0x2f8c7(%rip), %rax # 0x52878
movl %ecx, 0x1fe58(%rax)
movq %rdx, 0x1fe60(%rax)
addq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/posix_time.c |
glfwPlatformGetTimerValue | uint64_t _glfwPlatformGetTimerValue(void)
{
#if defined(CLOCK_MONOTONIC)
if (_glfw.timer.posix.monotonic)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t) ts.tv_sec * (uint64_t) 1000000000 + (uint64_t) ts.tv_nsec;
}
else
#endif
{
struct tim... | pushq %rbx
subq $0x10, %rsp
leaq 0x2f8a9(%rip), %rax # 0x52878
cmpl $0x0, 0x1fe58(%rax)
je 0x22fef
pushq $0x1
popq %rdi
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x13130
imulq $0x3b9aca00, (%rbx), %rax # imm = 0x3B9ACA00
jmp 0x23003
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x131f0
imulq $0xf4240, (%rbx), %... | /Konf[P]LearnOpenGL-CLion/glfw/src/posix_time.c |
glfwPlatformCreateTls | GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
{
assert(tls->posix.allocated == GLFW_FALSE);
if (pthread_key_create(&tls->posix.key, NULL) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"POSIX: Failed to create context TLS");
return GLFW_FALSE;
}
tls->posix.al... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jne 0x23062
movq %rdi, %r14
addq $0x4, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x13470
testl %eax, %eax
je 0x2304e
leaq 0x255d2(%rip), %rsi # 0x48612
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x17839
jmp 0x23058
movl $0x1, (%r14)
pushq $... | /Konf[P]LearnOpenGL-CLion/glfw/src/posix_thread.c |
glfwPlatformCreateMutex | GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex)
{
assert(mutex->posix.allocated == GLFW_FALSE);
if (pthread_mutex_init(&mutex->posix.handle, NULL) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "POSIX: Failed to create mutex");
return GLFW_FALSE;
}
return mutex->posix.allocated ... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jne 0x23132
movq %rdi, %r14
addq $0x8, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x13320
testl %eax, %eax
je 0x2311e
leaq 0x255f0(%rip), %rsi # 0x48700
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x17839
jmp 0x23128
movl $0x1, (%r14)
pushq $... | /Konf[P]LearnOpenGL-CLion/glfw/src/posix_thread.c |
glfwInitGLX | GLFWbool _glfwInitGLX(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_GLX_LIBRARY)
_GLFW_GLX_LIBRARY,
#elif defined(__CYGWIN__)
"libGL-1.so",
#else
"libGL.so.1",
"libGL.so",
#endif
NULL
};
if (_glfw.glx.handle)
return GLFW_TRUE;
for (i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2f69d(%rip), %r14 # 0x52878
cmpq $0x0, 0x20768(%r14)
je 0x231ed
pushq $0x1
popq %rbx
jmp 0x234f4
xorl %r15d, %r15d
leaq 0x2cb49(%rip), %r12 # 0x4fd40
pushq $0x1
popq %rbx
cmpq $0x10, %r15
je 0x234cf
movq (%r15,%r12), %rdi
movl %ebx, %esi
callq 0x1351... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
extensionSupportedGLX | static int extensionSupportedGLX(const char* extension)
{
const char* extensions =
glXQueryExtensionsString(_glfw.x11.display, _glfw.x11.screen);
if (extensions)
{
if (_glfwStringInExtensionString(extension, extensions))
return GLFW_TRUE;
}
return GLFW_FALSE;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x2f1ac(%rip), %rax # 0x52878
movq 0x1feb8(%rax), %rdi
movl 0x1fec0(%rax), %esi
callq *0x207b0(%rax)
testq %rax, %rax
je 0x236f8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1766f
testl %eax, %eax
je 0x236f8
pushq $0x1
popq %rax
jmp 0x236fa
xorl %eax, %eax
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
getProcAddressGLX | static GLFWglproc getProcAddressGLX(const char* procname)
{
if (_glfw.glx.GetProcAddress)
return _glfw.glx.GetProcAddress((const GLubyte*) procname);
else if (_glfw.glx.GetProcAddressARB)
return _glfw.glx.GetProcAddressARB((const GLubyte*) procname);
else
return _glfw_dlsym(_glfw.glx... | movq %rdi, %rsi
leaq 0x2f172(%rip), %rax # 0x52878
movq 0x207d8(%rax), %rcx
testq %rcx, %rcx
jne 0x2371e
movq 0x207e0(%rax), %rcx
testq %rcx, %rcx
je 0x23723
movq %rsi, %rdi
jmpq *%rcx
movq 0x20768(%rax), %rdi
jmp 0x13880
| /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
glfwCreateContextGLX | GLFWbool _glfwCreateContextGLX(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
int attribs[40];
GLXFBConfig native = NULL;
GLXContext share = NULL;
if (ctxconfig->share)
share = ctxconfig->share... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
andq $0x0, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x23780
movq 0x268(%rax), %r14
jmp 0x23783
xorl %r14d, %r14d
leaq 0x8(%rsp), %rsi
movq %rdx, %rdi
callq 0x23b1f
testl %eax, %eax
je 0x2384f
cmpl $0x30002... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
chooseGLXFBConfig | static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired,
GLXFBConfig* result)
{
GLXFBConfig* nativeConfigs;
_GLFWfbconfig* usableConfigs;
const _GLFWfbconfig* closest;
int i, nativeCount, usableCount;
const char* vendor;
GLFWbool trustWindowBit = GLFW_TRU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
leaq 0x2ed3c(%rip), %rax # 0x52878
movq 0x1feb8(%rax), %rdi
pushq $0x1
popq %rsi
callq *0x20780(%rax)
testq %rax, %rax
je 0x23b68
leaq 0x2512f(%rip), %rsi # 0x48c87
movq %rax, %rdi
callq 0x13... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
makeContextCurrentGLX | static void makeContextCurrentGLX(_GLFWwindow* window)
{
if (window)
{
if (!glXMakeCurrent(_glfw.x11.display,
window->context.glx.window,
window->context.glx.handle))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
... | pushq %rbx
movq %rdi, %rbx
leaq 0x2ea88(%rip), %rcx # 0x52878
movq 0x207a0(%rcx), %rax
movq 0x1feb8(%rcx), %rdi
testq %rbx, %rbx
je 0x23e20
movq 0x268(%rbx), %rdx
movq 0x270(%rbx), %rsi
callq *%rax
testl %eax, %eax
jne 0x23e2a
leaq 0x24e90(%rip), %rsi # 0x48cae
jmp 0x23e46
xorl %esi, %esi
xorl %edx, %edx
callq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
glfwGetGLXContext | GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.glx.hand... | pushq %rbx
leaq 0x2e8a7(%rip), %rax # 0x52878
cmpl $0x0, (%rax)
je 0x23fe8
cmpl $0x0, 0x1f0(%rdi)
je 0x23ff1
movq 0x268(%rdi), %rbx
jmp 0x24001
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x23ff8
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
glfwGetGLXWindow | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return None;
}
return window->context.glx.window... | pushq %rbx
leaq 0x2e86a(%rip), %rax # 0x52878
cmpl $0x0, (%rax)
je 0x24025
cmpl $0x0, 0x1f0(%rdi)
je 0x2402e
movq 0x270(%rdi), %rbx
jmp 0x2403e
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x24035
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.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
"libE... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2e7f5(%rip), %r14 # 0x52878
cmpq $0x0, 0x208b0(%r14)
je 0x24095
pushq $0x1
popq %rbx
jmp 0x24480
xorl %r15d, %r15d
leaq 0x2bcc1(%rip), %r12 # 0x4fd60
pushq $0x1
popq %rbx
cmpq $0x1, %r15
je 0x2438d
movq (%r12,%r15,8), %rdi
movl %ebx, %esi
callq 0x135... | /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
glfwTerminateEGL | void _glfwTerminateEGL(void)
{
if (_glfw.egl.display)
{
eglTerminate(_glfw.egl.display);
_glfw.egl.display = EGL_NO_DISPLAY;
}
if (_glfw.egl.handle)
{
_glfw_dlclose(_glfw.egl.handle);
_glfw.egl.handle = NULL;
}
} | pushq %rbx
leaq 0x2e3e2(%rip), %rbx # 0x52878
movq 0x20888(%rbx), %rdi
testq %rdi, %rdi
je 0x244b0
callq *0x208e0(%rbx)
andq $0x0, 0x20888(%rbx)
movq 0x208b0(%rbx), %rdi
testq %rdi, %rdi
je 0x244c9
callq 0x139b0
andq $0x0, 0x208b0(%rbx)
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/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))
{
_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2dc75(%rip), %r14 # 0x52878
movq 0x20888(%r14), %rdi
movq 0x20910(%r14), %rax
testq %rbx, %rbx
je 0x24c44
movq 0x280(%rbx), %rcx
movq 0x288(%rbx), %rdx
movq %rdx, %rsi
callq *%rax
testl %eax, %eax
jne 0x24c50
callq *0x208d0(%r14)
movl %eax, %edi
callq 0x244cb
... | /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
getProcAddressEGL | static GLFWglproc getProcAddressEGL(const char* procname)
{
_GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (window->context.egl.client)
{
GLFWglproc proc = (GLFWglproc) _glfw_dlsym(window->context.egl.client,
procname);
i... | pushq %rbx
movq %rdi, %rbx
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x2b2dc(%rip), %rdi # 0x4ffe8
callq 0x23096
movq 0x290(%rax), %rdi
testq %rdi, %rdi
je 0x24d2c
movq %rbx, %rsi
callq 0x13880
testq %rax, %rax
je 0x24d2c
popq %rbx
retq
leaq 0x2db45(%rip), %rax # 0x52878
movq %rbx, %rdi
popq %rbx
jmpq *... | /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
destroyContextEGL | static void destroyContextEGL(_GLFWwindow* window)
{
#if defined(_GLFW_X11)
// NOTE: Do not unload libGL.so.1 while the X11 display is still open,
// as it will make XCloseDisplay segfault
if (window->context.client != GLFW_OPENGL_API)
#endif // _GLFW_X11
{
if (window->context.egl.client)
... | pushq %rbx
movq %rdi, %rbx
cmpl $0x30001, 0x1f0(%rdi) # imm = 0x30001
je 0x24d66
movq 0x290(%rbx), %rdi
testq %rdi, %rdi
je 0x24d66
callq 0x139b0
andq $0x0, 0x290(%rbx)
movq 0x288(%rbx), %rsi
testq %rsi, %rsi
je 0x24d8e
leaq 0x2daff(%rip), %rax # 0x52878
movq 0x20888(%rax), %rdi
callq *0x208f8(%rax)
andq $0x0, 0x... | /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
glfwChooseVisualEGL | GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
XVisualInfo* result;
XVisualInfo desired;
EGLConfig native;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movq %rcx, %r14
andl $0x0, 0xc(%rsp)
movq %rsi, %rdi
andl $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x24957
testl %eax, %eax
je 0x24e5c
leaq 0x2da87(%rip), %r12 # 0x52878
movq 0x20888(%r12), %rdi
movq 0x10(... | /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
glfwGetEGLSurface | GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_SURFACE);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_SURFACE;
}
return wind... | pushq %rbx
leaq 0x2d979(%rip), %rax # 0x52878
cmpl $0x0, (%rax)
je 0x24f16
cmpl $0x0, 0x1f0(%rdi)
je 0x24f1f
movq 0x288(%rdi), %rbx
jmp 0x24f2f
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x24f26
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/egl_context.c |
glfwGetOSMesaColorBuffer | GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
int* height, int* format, void** buffer)
{
void* mesaBuffer;
GLint mesaWidth, mesaHeight, mesaFormat;
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x254d3
leaq 0x2d444(%rip), %rax # 0x52878
cmpl $0x0, (%rax)
je 0x254a2
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x298(%rdi), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
leaq 0x10(%rsp... | /Konf[P]LearnOpenGL-CLion/glfw/src/osmesa_context.c |
glfwGetOSMesaContext | GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.os... | pushq %rbx
leaq 0x2d2a5(%rip), %rax # 0x52878
cmpl $0x0, (%rax)
je 0x255ea
cmpl $0x0, 0x1f0(%rdi)
je 0x255f3
movq 0x298(%rdi), %rbx
jmp 0x25603
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x255fa
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /Konf[P]LearnOpenGL-CLion/glfw/src/osmesa_context.c |
glfwInitJoysticksLinux | GLFWbool _glfwInitJoysticksLinux(void)
{
DIR* dir;
int count = 0;
const char* dirname = "/dev/input";
_glfw.linjs.inotify = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
if (_glfw.linjs.inotify > 0)
{
// HACK: Register for IN_ATTRIB to get notified when udev is done
// This wor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp # imm = 0x1018
movl $0x80800, %edi # imm = 0x80800
callq 0x13570
leaq 0x2d24e(%rip), %rbx # 0x52878
movl %eax, 0x20838(%rbx)
testl %eax, %eax
jle 0x2564d
leaq 0x241a7(%rip), %rsi # 0x497e2
movl %eax, %edi
mov... | /Konf[P]LearnOpenGL-CLion/glfw/src/linux_joystick.c |
openJoystickDevice | static GLFWbool openJoystickDevice(const char* path)
{
int jid, code;
char name[256] = "";
char guid[33] = "";
char evBits[(EV_CNT + 7) / 8] = {0};
char keyBits[(KEY_CNT + 7) / 8] = {0};
char absBits[(ABS_CNT + 7) / 8] = {0};
int axisCount = 0, buttonCount = 0, hatCount = 0;
struct input... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20e8, %rsp # imm = 0x20E8
movq %rdi, %rbx
leaq 0xc0(%rsp), %rdi
movl $0x100, %edx # imm = 0x100
xorl %esi, %esi
callq 0x130d0
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andl $0x0, 0x14(%rsp)
movaps %xmm0, 0x30(%rsp)
movb $0x... | /Konf[P]LearnOpenGL-CLion/glfw/src/linux_joystick.c |
glfwTerminateJoysticksLinux | void _glfwTerminateJoysticksLinux(void)
{
int jid;
for (jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
{
_GLFWjoystick* js = _glfw.joysticks + jid;
if (js->present)
closeJoystick(js);
}
regfree(&_glfw.linjs.regex);
if (_glfw.linjs.inotify > 0)
{
if (_glfw... | pushq %r14
pushq %rbx
pushq %rax
movl $0x400, %r14d # imm = 0x400
leaq 0x2cc78(%rip), %rbx # 0x52878
cmpq $0x1fe00, %r14 # imm = 0x1FE00
je 0x25c22
cmpl $0x0, (%rbx,%r14)
je 0x25c19
leaq (%rbx,%r14), %rdi
callq 0x25c61
addq $0x1fa0, %r14 # imm = 0x1FA0
jmp 0x25c00
leaq 0x20840(%rbx), %r... | /Konf[P]LearnOpenGL-CLion/glfw/src/linux_joystick.c |
pollAbsState | static void pollAbsState(_GLFWjoystick* js)
{
int code;
for (code = 0; code < ABS_CNT; code++)
{
if (js->linjs.absMap[code] < 0)
continue;
struct input_absinfo* info = &js->linjs.absInfo[code];
if (ioctl(js->linjs.fd, EVIOCGABS(code), info) < 0)
continue;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x187c, %r12d # imm = 0x187C
movl $0x197c, %r13d # imm = 0x197C
movl $0x80184540, %ebp # imm = 0x80184540
xorl %r14d, %r14d
cmpq $0x197c, %r12 # imm = 0x197C
je 0x25f0b
cmpl $0x0, (%rbx,%... | /Konf[P]LearnOpenGL-CLion/glfw/src/linux_joystick.c |
handleAbsEvent | static void handleAbsEvent(_GLFWjoystick* js, int code, int value)
{
const int index = js->linjs.absMap[code];
if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
{
static const char stateMap[3][3] =
{
{ GLFW_HAT_CENTERED, GLFW_HAT_UP, GLFW_HAT_DOWN },
{ GLFW_HAT_LEFT,... | movl %esi, %eax
movslq %esi, %rcx
movl 0x187c(%rdi,%rcx,4), %esi
movl %ecx, %r8d
andl $-0x8, %r8d
cmpl $0x10, %r8d
jne 0x25f57
leal -0x10(%rax), %ecx
shrl %ecx
andl $0x1, %eax
leaq (%rdi,%rcx,8), %rcx
addq $0x1f7c, %rcx # imm = 0x1F7C
movl %eax, %eax
testl %edx, %edx
je 0x25f96
js 0x25f9c
movl $0x2, (%rcx,%ra... | /Konf[P]LearnOpenGL-CLion/glfw/src/linux_joystick.c |
Pa2AlsaFormat | static snd_pcm_format_t Pa2AlsaFormat( PaSampleFormat paFormat )
{
switch( paFormat )
{
case paFloat32:
return SND_PCM_FORMAT_FLOAT;
case paInt16:
return SND_PCM_FORMAT_S16;
case paInt24:
#ifdef PA_LITTLE_ENDIAN
return SND_PCM_FORMAT_S24_3LE;
#elif d... | leaq -0x1(%rdi), %rax
cmpq $0x7, %rax
ja 0xac7b
leaq 0x962a(%rip), %rcx # 0x14298
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0xe
jmp 0xac99
cmpq $0x10, %rdi
je 0xac9b
cmpq $0x20, %rdi
jne 0xac8b
pushq $0x1
jmp 0xac99
pushq $-0x1
jmp 0xac99
pushq $0x2
jmp 0xac99
pushq $0xa
jmp 0xac99
pushq $0x20
p... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsaStream_Terminate | static void PaAlsaStream_Terminate( PaAlsaStream *self )
{
assert( self );
if( self->capture.pcm )
{
PaAlsaStreamComponent_Terminate( &self->capture );
}
if( self->playback.pcm )
{
PaAlsaStreamComponent_Terminate( &self->playback );
}
PaUtil_FreeMemory( self->pfds );
... | pushq %rbx
testq %rdi, %rdi
je 0xb8d3
movq %rdi, %rbx
cmpq $0x0, 0x2c0(%rdi)
je 0xb898
leaq 0x288(%rbx), %rdi
callq 0xcaa8
cmpq $0x0, 0x340(%rbx)
je 0xb8ae
leaq 0x308(%rbx), %rdi
callq 0xcaa8
movq 0x230(%rbx), %rdi
callq 0x7a91
leaq 0x248(%rbx), %rdi
callq 0x8014
testl %eax, %eax
jne 0xb8f2
movq %rbx, %rdi
popq %rbx
jm... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsaStreamComponent_Initialize | static PaError PaAlsaStreamComponent_Initialize( PaAlsaStreamComponent *self, PaAlsaHostApiRepresentation *alsaApi,
const PaStreamParameters *params, StreamDirection streamDir, int callbackMode )
{
PaError result = paNoError;
PaSampleFormat userSampleFormat = params->sampleFormat, hostSampleFormat = paN... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rdx)
jle 0xbaf0
movl %r8d, %r13d
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movup... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
LogAllAvailableFormats | static void LogAllAvailableFormats( snd_pcm_t *pcm )
{
PaSampleFormat available = 0;
snd_pcm_hw_params_t *hwParams;
alsa_snd_pcm_hw_params_alloca( &hwParams );
alsa_snd_pcm_hw_params_any( pcm, hwParams );
PA_DEBUG(( " --- Supported Formats ---\n" ));
if( alsa_snd_pcm_hw_params_test_format( pc... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6270
movq %rsp, %r14
leaq 0xf(%rax), %rcx
andq $-0x10, %rcx
subq %rcx, %r14
movq %r14, %rsp
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x6080
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6060
movq ... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsaStreamComponent_InitialConfigure | static PaError PaAlsaStreamComponent_InitialConfigure( PaAlsaStreamComponent *self, const PaStreamParameters *params,
int primeBuffers, snd_pcm_hw_params_t *hwParams, double *sampleRate )
{
/* Configuration consists of setting all of ALSA's parameters.
* These parameters come in two flavors: hardware p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x38(%rdi), %r15
movsd (%rdx), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl $0x2, 0xc(%rsp)
movq %r15, %rdi
callq 0x6060
testl %eax, %eax
js 0xbfdd
movq %r15, %rdi
movq %... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsaStreamComponent_FinishConfigure | static PaError PaAlsaStreamComponent_FinishConfigure( PaAlsaStreamComponent *self, snd_pcm_hw_params_t* hwParams,
const PaStreamParameters *params, int primeBuffers, double sampleRate, PaTime* latency )
{
PaError result = paNoError;
snd_pcm_sw_params_t* swParams;
snd_pcm_uframes_t bufSz = 0;
*la... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, -0x30(%rbp)
movl %ecx, %r12d
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %r8, -0x38(%rbp)
movq %rax, (%r8)
callq 0x6190
movq %rsp, %r14
l... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsaStreamComponent_DetermineFramesPerBuffer | static PaError PaAlsaStreamComponent_DetermineFramesPerBuffer( PaAlsaStreamComponent* self, const PaStreamParameters* params,
unsigned long framesPerUserBuffer, double sampleRate, snd_pcm_hw_params_t* hwParams, int* accurate )
{
PaError result = paNoError;
unsigned long bufferSize, framesPerHostBuffer;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rdx, %r13
mulsd 0x10(%rsi), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
subsd 0x7b5a(%rip), %xmm0 # 0x14290
cvttsd2si %xmm0, %r12
andq %rdx, %r12
orq %rax, %r12
cmpq %r13, %r12
cmovbeq %r13... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
AlsaStart | static PaError AlsaStart( PaAlsaStream *stream, int priming )
{
PaError result = paNoError;
if( stream->playback.pcm )
{
if( stream->callbackMode )
{
if( !priming )
{
/* Buffer isn't primed, so prepare and silence */
ENSURE_( alsa_snd_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x340(%rdi), %rdi
testq %rdi, %rdi
je 0xcfe9
movl 0x224(%rbx), %r14d
callq 0x6180
movl %eax, %ebp
testl %r14d, %r14d
je 0xcfe1
testl %ebp, %ebp
js 0xd030
cmpl $0x0, 0x320(%rbx)
je 0xcfe9
movq 0x340(%rbx), %rdi
callq 0x6130
leaq... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
OnExit | static void OnExit( void *data )
{
PaAlsaStream *stream = (PaAlsaStream *) data;
assert( data );
PaUtil_ResetCpuLoadMeasurer( &stream->cpuLoadMeasurer );
stream->callback_finished = 1; /* Let the outside world know stream was stopped in callback */
PA_DEBUG(( "%s: Stopping ALSA handles\n", __FUN... | pushq %rbx
movq %rdi, %rbx
addq $0x50, %rdi
callq 0xfdba
movl $0x1, 0x23c(%rbx)
movl 0x240(%rbx), %eax
movq %rbx, %rdi
callq 0xdd3f
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xd16c
movq 0x28(%rbx), %rdi
callq *%rax
movl $0x0, 0x244(%rbx)
popq %rbx
retq
| /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsaStream_WaitForFrames | static PaError PaAlsaStream_WaitForFrames( PaAlsaStream *self, unsigned long *framesAvail, int *xrunOccurred )
{
PaError result = paNoError;
int pollPlayback = self->playback.pcm != NULL, pollCapture = self->capture.pcm != NULL;
int pollTimeout = self->pollTimeout;
int xrun = 0, timeouts = 0;
int po... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x40(%rsp)
xorl %r13d, %r13d
cmpq $0x0, 0x340(%rdi)
setne %r13b
movl %r13d, 0xc(%rsp)
xorl %ebx, %ebx
cmpq $0x0, 0x2c0(%rdi)
setne %bl
movl %ebx, 0x8(%rsp)
movl 0x238(%rdi), %eax
movl %eax, 0x24(%rsp)
andl $0x0, 0x4(%rsp)
movq... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
PaAlsaStreamComponent_BeginPolling | static PaError PaAlsaStreamComponent_BeginPolling( PaAlsaStreamComponent* self, struct pollfd* pfds )
{
PaError result = paNoError;
int ret = alsa_snd_pcm_poll_descriptors( self->pcm, pfds, self->nfds );
(void)ret; /* Prevent unused variable warning if asserts are turned off */
assert( ret == self->nfd... | pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movl 0x54(%rbx), %edx
callq 0x6660
cmpl 0x54(%rbx), %eax
jne 0xdf65
andl $0x0, 0x58(%rbx)
popq %rbx
retq
leaq 0xdd98(%rip), %rdi # 0x1bd04
leaq 0x6b70(%rip), %rsi # 0x14ae3
leaq 0xdd9c(%rip), %rcx # 0x1bd16
movl $0xe34, %edx # imm = 0xE34
callq ... | /syb0rg[P]PortAudio2/src/hostapi/alsa/pa_linux_alsa.c |
Float32_To_Int16_DitherClip | static void Float32_To_Int16_DitherClip(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
PaInt16 *dest = (PaInt16*)destinationBuffer... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %r15
movslq %ecx, %r12
movslq %esi, %r13
addq %r13, %r13
shlq $0x2, %r12
subl $0x1, %ebp
jb 0xf3f4
movq %rbx, %rdi
callq 0xfe81
movss (%r14), %xmm1
mulss 0xef84(%rip), %xmm1 # 0x1e3... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Float32_To_Int8 | static void Float32_To_Int8(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
signed char *dest = (signed char*)destinationBuffer;
... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rax
movss 0xef3f(%rip), %xmm0 # 0x1e354
subl $0x1, %r8d
jb 0xf432
movss (%rdx), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %esi
movb %sil, (%rdi)
addq %rcx, %rdi
addq %rax, %rdx
jmp 0xf415
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Float32_To_Int8_Clip | static void Float32_To_Int8_Clip(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
signed char *dest = (signed char*)destinationBuffe... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rax
movss 0xeeb2(%rip), %xmm0 # 0x1e354
movss 0xeeb2(%rip), %xmm1 # 0x1e35c
subl $0x1, %r8d
jb 0xf4d5
movss (%rdx), %xmm2
mulss %xmm0, %xmm2
movaps %xmm1, %xmm3
maxss %xmm2, %xmm3
movaps %xmm0, %xmm2
minss %xmm3, %xmm2
cvttss2si %xmm2, %esi
movb %sil, (%rdi)
addq ... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Float32_To_Int8_DitherClip | static void Float32_To_Int8_DitherClip(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
signed char *dest = (signed char*)destinatio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %r15
movslq %ecx, %r12
movslq %esi, %r13
shlq $0x2, %r12
subl $0x1, %ebp
jb 0xf53c
movq %rbx, %rdi
callq 0xfe81
movss (%r14), %xmm1
mulss 0xee47(%rip), %xmm1 # 0x1e358
addss %xmm0, ... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Float32_To_UInt8 | static void Float32_To_UInt8(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
unsigned char *dest = (unsigned char*)destinationBuffe... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rax
movss 0xedf7(%rip), %xmm0 # 0x1e354
subl $0x1, %r8d
jb 0xf57e
movss (%rdx), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %esi
addb $-0x80, %sil
movb %sil, (%rdi)
addq %rcx, %rdi
addq %rax, %rdx
jmp 0xf55d
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Float32_To_UInt8_Dither | static void Float32_To_UInt8_Dither(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
unsigned char *dest = (unsigned char*)destinati... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %r15
movslq %ecx, %r12
movslq %esi, %r13
shlq $0x2, %r12
subl $0x1, %ebp
jb 0xf5cf
movq %rbx, %rdi
callq 0xfe81
movss (%r14), %xmm1
mulss 0xed9e(%rip), %xmm1 # 0x1e358
addss %xmm0, ... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Float32_To_UInt8_Clip | static void Float32_To_UInt8_Clip(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
float *src = (float*)sourceBuffer;
unsigned char *dest = (unsigned char*)destination... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rax
movss 0xed64(%rip), %xmm0 # 0x1e354
movss 0xed64(%rip), %xmm1 # 0x1e35c
subl $0x1, %r8d
jb 0xf627
movss (%rdx), %xmm2
mulss %xmm0, %xmm2
movaps %xmm1, %xmm3
maxss %xmm2, %xmm3
movaps %xmm0, %xmm2
minss %xmm3, %xmm2
cvttss2si %xmm2, %esi
addb $-0x80, %sil
movb ... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int32_To_Float32 | static void Int32_To_Float32(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt32 *src = (PaInt32*)sourceBuffer;
float *dest = (float*)destinationBuffer;
(void... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rax
shlq $0x2, %rcx
movsd 0xeccb(%rip), %xmm0 # 0x1e380
subl $0x1, %r8d
jb 0xf6d3
cvtsi2sdl (%rdx), %xmm1
mulsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movss %xmm1, (%rdi)
addq %rax, %rdx
addq %rcx, %rdi
jmp 0xf6b5
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int32_To_Int16 | static void Int32_To_Int16(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt32 *src = (PaInt32*)sourceBuffer;
PaInt16 *dest = (PaInt16*)destinationBuffer;
(vo... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rax
addq %rcx, %rcx
subl $0x1, %r8d
jb 0xf72e
movzwl 0x2(%rdx), %esi
movw %si, (%rdi)
addq %rax, %rdx
addq %rcx, %rdi
jmp 0xf719
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int32_To_Int8 | static void Int32_To_Int8(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt32 *src = (PaInt32*)sourceBuffer;
signed char *dest = (signed char*)destinationBuffer;
... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rax
subl $0x1, %r8d
jb 0xf7a4
movb 0x3(%rdx), %sil
movb %sil, (%rdi)
addq %rcx, %rdi
addq %rax, %rdx
jmp 0xf78f
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int32_To_Int8_Dither | static void Int32_To_Int8_Dither(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt32 *src = (PaInt32*)sourceBuffer;
signed char *dest = (signed char*)destinationB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %r15
movslq %ecx, %r12
movslq %esi, %r13
shlq $0x2, %r12
subl $0x1, %ebp
jb 0xf7e8
movq %rbx, %rdi
callq 0xfe55
movl (%r14), %ecx
shrl %ecx
addl %eax, %ecx
shrl $0x17, %ecx
movb %cl, (%... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int32_To_UInt8_Dither | static void Int32_To_UInt8_Dither(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt32 *src = (PaInt32*)sourceBuffer;
unsigned char *dest = (unsigned char*)destina... | retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int24_To_Int32 | static void Int24_To_Int32(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
unsigned char *src = (unsigned char*)sourceBuffer;
PaInt32 *dest = (PaInt32*) destinationB... | leal (%rcx,%rcx,2), %eax
cltq
movslq %esi, %rcx
addq $0x2, %rdx
shlq $0x2, %rcx
subl $0x1, %r8d
jb 0xf899
movzwl -0x2(%rdx), %esi
shll $0x8, %esi
movzbl (%rdx), %r9d
shll $0x18, %r9d
orl %esi, %r9d
movl %r9d, (%rdi)
addq %rax, %rdx
addq %rcx, %rdi
jmp 0xf876
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int24_To_Int16_Dither | static void Int24_To_Int16_Dither(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
unsigned char *src = (unsigned char*)sourceBuffer;
PaInt16 *dest = (PaInt16*)destinat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movq %rdx, %r14
movq %rdi, %r15
leal (%rcx,%rcx,2), %eax
movslq %eax, %r12
movslq %esi, %r13
addq %r13, %r13
addq $0x2, %r14
subl $0x1, %ebp
jb 0xf915
movzwl -0x2(%r14), %eax
shll $0x7, %eax
movzbl (%r14), %ebx... | /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int24_To_Int8 | static void Int24_To_Int8(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
unsigned char *src = (unsigned char*)sourceBuffer;
signed char *dest = (signed char*)destina... | leal (%rcx,%rcx,2), %eax
cltq
movslq %esi, %rcx
addq $0x2, %rdx
subl $0x1, %r8d
jb 0xf944
movb (%rdx), %sil
movb %sil, (%rdi)
addq %rcx, %rdi
addq %rax, %rdx
jmp 0xf930
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int24_To_UInt8 | static void Int24_To_UInt8(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
unsigned char *src = (unsigned char*)sourceBuffer;
unsigned char *dest = (unsigned char*)des... | leal (%rcx,%rcx,2), %eax
cltq
movslq %esi, %rcx
addq $0x2, %rdx
subl $0x1, %r8d
jb 0xf9cc
movb (%rdx), %sil
addb $-0x80, %sil
movb %sil, (%rdi)
addq %rcx, %rdi
addq %rax, %rdx
jmp 0xf9b4
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int16_To_Float32 | static void Int16_To_Float32(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt16 *src = (PaInt16*)sourceBuffer;
float *dest = (float*)destinationBuffer;
(void... | movslq %ecx, %rax
movslq %esi, %rcx
addq %rax, %rax
shlq $0x2, %rcx
movss 0xe97d(%rip), %xmm0 # 0x1e360
subl $0x1, %r8d
jb 0xfa00
movswl (%rdx), %esi
cvtsi2ss %esi, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi)
addq %rax, %rdx
addq %rcx, %rdi
jmp 0xf9e3
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int16_To_Int24 | static void Int16_To_Int24(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt16 *src = (PaInt16*) sourceBuffer;
unsigned char *dest = (unsigned char*)destinationB... | pushq %rbx
movslq %ecx, %rax
leal (%rsi,%rsi,2), %ecx
movslq %ecx, %rcx
addq %rax, %rax
addq $0x2, %rdi
subl $0x1, %r8d
jb 0xfa50
movzwl (%rdx), %ebx
movb $0x0, -0x2(%rdi)
movb %bl, -0x1(%rdi)
movb %bh, (%rdi)
addq %rax, %rdx
addq %rcx, %rdi
jmp 0xfa36
popq %rbx
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int16_To_Int8_Dither | static void Int16_To_Int8_Dither(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt16 *src = (PaInt16*)sourceBuffer;
signed char *dest = (signed char*)destinationB... | retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int16_To_UInt8_Dither | static void Int16_To_UInt8_Dither(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaInt16 *src = (PaInt16*)sourceBuffer;
unsigned char *dest = (unsigned char*)destina... | retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Int8_To_Int32 | static void Int8_To_Int32(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
signed char *src = (signed char*)sourceBuffer;
PaInt32 *dest = (PaInt32*)destinationBuffer;
... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rcx
subl $0x1, %r8d
jb 0xfae6
movzbl (%rdx), %esi
shll $0x18, %esi
movl %esi, (%rdi)
addq %rax, %rdx
addq %rcx, %rdi
jmp 0xfad0
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
Copy_32_To_32 | static void Copy_32_To_32(
void *destinationBuffer, signed int destinationStride,
void *sourceBuffer, signed int sourceStride,
unsigned int count, struct PaUtilTriangularDitherGenerator *ditherGenerator )
{
PaUint32 *dest = (PaUint32 *)destinationBuffer;
PaUint32 *src = (PaUint32 *)sourceBuffer;
... | movslq %ecx, %rax
movslq %esi, %rcx
shlq $0x2, %rcx
shlq $0x2, %rax
subl $0x1, %r8d
jb 0xfcaa
movl (%rdx), %esi
movl %esi, (%rdi)
addq %rcx, %rdi
addq %rax, %rdx
jmp 0xfc98
retq
| /syb0rg[P]PortAudio2/src/common/pa_converters.c |
AdaptingOutputOnlyProcess | static unsigned long AdaptingOutputOnlyProcess( PaUtilBufferProcessor *bp,
int *streamCallbackResult,
PaUtilChannelDescriptor *hostOutputChannels,
unsigned long framesToProcess )
{
void *userInput, *userOutput;
unsigned char *srcBytePtr;
unsigned int srcSampleStrideSamples; /* stride... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
leaq 0x90(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x98(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x108(%rdi), %rax
movq %rax, 0x40(%rsp)
xorl %r13d, %r13d
movq 0xa0(... | /syb0rg[P]PortAudio2/src/common/pa_process.c |
PaUtil_CopyInput | unsigned long PaUtil_CopyInput( PaUtilBufferProcessor* bp,
void **buffer, unsigned long frameCount )
{
PaUtilChannelDescriptor *hostInputChannels;
unsigned int framesToCopy;
unsigned char *destBytePtr;
void **nonInterleavedDestPtrs;
unsigned int destSampleStrideSamples; /* stride from one sa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0xc0(%rdi), %rax
cmpq %rdx, %rax
cmovbq %rax, %rbx
movq 0xd0(%rdi), %r12
cmpl $0x0, 0x34(%rdi)
movq (%rsi), %r15
je 0x11cac
movq %rsi, 0x8(%rsp)
movl 0x28(%r14), %eax
movl 0x30(%r14), %ecx
movq %rcx, ... | /syb0rg[P]PortAudio2/src/common/pa_process.c |
CopyTempOutputBuffersToHostOutputBuffers | static void CopyTempOutputBuffersToHostOutputBuffers( PaUtilBufferProcessor *bp)
{
unsigned long maxFramesToCopy;
PaUtilChannelDescriptor *hostOutputChannels;
unsigned int frameCount;
unsigned char *srcBytePtr;
unsigned int srcSampleStrideSamples; /* stride from one sample to the next within a chann... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xe8(%rdi), %rsi
leaq 0xf0(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x108(%rdi), %rax
movq %rax, 0x20(%rsp)
movq 0xa0(%rdi), %rcx
movq %rsi, 0x18(%rsp)
testq %rcx, %rcx
je 0x11fc8
movq (%rsi), %rdx
movq 0x10(%rsp), %ra... | /syb0rg[P]PortAudio2/src/common/pa_process.c |
PaUtil_InitializeStreamInterface | void PaUtil_InitializeStreamInterface( PaUtilStreamInterface *streamInterface,
PaError (*Close)( PaStream* ),
PaError (*Start)( PaStream* ),
PaError (*Stop)( PaStream* ),
... | movq 0x38(%rsp), %rax
movaps 0x28(%rsp), %xmm0
movaps 0x18(%rsp), %xmm1
movaps 0x8(%rsp), %xmm2
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq %r9, 0x20(%rdi)
movups %xmm2, 0x28(%rdi)
movups %xmm1, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movq %rax, 0x58(%rdi)
retq
| /syb0rg[P]PortAudio2/src/common/pa_stream.c |
Catch::AssertionResult::AssertionResult(Catch::AssertionInfo const&, Catch::AssertionResultData const&) | AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
: m_info( info ),
m_resultData( data )
{} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x38(%rdi), %r15
leaq 0x48(%rdi), %r12
mov... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::AssertionResult::getExpression[abi:cxx11]() const | std::string AssertionResult::getExpression() const {
// Possibly overallocating by 3 characters should be basically free
std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
if (isFalseTest(m_info.resultDisposition)) {
expr += "!(";
}
expr += m_info.c... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x28(%rsi), %rsi
addq $0x3, %rsi
callq 0x12880
testb $0x4, 0x30(%r14)
je 0x14915
leaq 0x54ee0(%rip), %rsi # 0x697ed
movq %rbx, %rdi
callq 0x12ab0
movq 0x20(%r14), ... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::operator<<(std::ostream&, Catch::SourceLineInfo const&) | std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
#ifndef __GNUG__
os << info.file << '(' << info.line << ')';
#else
os << info.file << ':' << info.line;
#endif
return os;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
je 0x1aca4
movq %r15, %rdi
callq 0x12210
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x12630
jmp 0x1acbb
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %e... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::Config::Config(Catch::ConfigData const&) | Config::Config( ConfigData const& data )
: m_data( data ),
m_stream( openStream() )
{
// We need to trim filter specs to avoid trouble with superfluous
// whitespace (esp. important for bdd macros, as those are manually
// aligned with whitespace).
for (auto& elem : m_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbx
leaq 0x73e8b(%rip), %rax # 0x8ebc0
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x419c8
movq 0x68(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movq 0x70(%rbx), %rax
mov... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::splitStringRef(Catch::StringRef, char) | std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
std::vector<StringRef> subStrings;
std::size_t start = 0;
for(std::size_t pos = 0; pos < str.size(); ++pos ) {
if( str[pos] == delimiter ) {
if( pos - start > 1 )
subStrings.p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x1bd45
movl %ecx, %ebp
leaq 0x4e1f8(%rip), %r12 # 0x69ec7
xorl %r13d, %r13d
xorl %eax, %eax
cmpb %bpl,... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::FatalConditionHandler::engage_platform() | void FatalConditionHandler::engage_platform() {
stack_t sigStack;
sigStack.ss_sp = altStackMem;
sigStack.ss_size = altStackSize;
sigStack.ss_flags = 0;
sigaltstack(&sigStack, &oldSigStack);
struct sigaction sa = { };
sa.sa_handler = handleSignal;
sa.sa_fl... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x77687(%rip), %rax # 0x93a28
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq 0x77680(%rip), %rax # 0x93a30
movq %rax, 0x10(%rdi)
movl $0x0, 0x8(%rdi)
leaq 0x77676(%rip), %rsi # 0x93a38
callq 0x12a40
leaq 0x20(%rsp), %rbx
xorl %r15d, %r15d
movl $... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::handleSignal(int) | static void handleSignal( int sig ) {
char const * name = "<unknown signal>";
for (auto const& def : signalDefs) {
if (sig == def.id) {
name = def.name;
break;
}
}
// We need to restore previous signal handlers and let them do
... | pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x4f488(%rip), %r14 # 0x6b8c5
movl $0x8, %ecx
leaq 0x728e7(%rip), %rax # 0x8ed30
movl -0x8(%rcx,%rax), %edx
cmpl %ebx, %edx
jne 0x1c455
movq (%rcx,%rax), %r14
cmpl %ebx, %edx
je 0x1c466
leaq 0x10(%rcx), %rdx
cmpq $0x58, %rcx
movq %rdx, %rcx
jne 0x1c449
callq... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::ReporterConfig::ReporterConfig(std::shared_ptr<Catch::IConfig const> const&) | ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
: m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, (%r14)
movq (%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x1c5b5
movq 0x769f1(%rip), %rcx # 0x92f98
cmpb $0x0, (%rcx)
je 0x1c5b1
incl ... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::ReporterConfig::ReporterConfig(std::shared_ptr<Catch::IConfig const> const&, std::ostream&) | ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
: m_stream( &_stream ), m_fullConfig( _fullConfig ) {} | movq %rdx, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x1c5e9
movq 0x769bc(%rip), %rcx # 0x92f98
cmpb $0x0, (%rcx)
je 0x1c5e5
incl 0x8(%rax)
retq
lock
incl 0x8(%rax)
retq
| /olegtarasov[P]fastText/src/catch.hpp |
Catch::GroupInfo::GroupInfo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long) | GroupInfo::GroupInfo( std::string const& _name,
std::size_t _groupIndex,
std::size_t _groupsCount )
: name( _name ),
groupIndex( _groupIndex ),
groupsCounts( _groupsCount )
{} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x4e742
movq %r14, 0x20(%r15)
movq %rbx, 0x28(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
| /olegtarasov[P]fastText/src/catch.hpp |
Catch::AssertionStats::AssertionStats(Catch::AssertionResult const&, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> const&, Catch::Totals const&) | AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
Totals const& _totals )
: assertionResult( _assertionResult ),
infoMessages( _infoMessages ),
totals( _t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x72712(%rip), %rax # 0x8eda0
movq %rax, (%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm0, 0x8(%rdi)
movups %xmm1, 0x18(%r... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::AssertionStats::~AssertionStats() | AssertionStats::~AssertionStats() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x7245b(%rip), %rax # 0x8eda0
movq %rax, (%rdi)
addq $0x98, %rdi
callq 0x42074
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x1c96c
movq (%rax), %rsi
incq %rsi
callq 0x12570
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0x1c985
movq (%rbx), %rsi
incq %rs... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::TestGroupStats::~TestGroupStats() | TestGroupStats::~TestGroupStats() = default; | movq %rdi, %rax
leaq 0x720a8(%rip), %rcx # 0x8ee00
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0x1cd73
movq (%rax), %rsi
incq %rsi
jmp 0x12570
retq
| /olegtarasov[P]fastText/src/catch.hpp |
Catch::TestRunStats::~TestRunStats() | TestRunStats::~TestRunStats() = default; | movq %rdi, %rax
leaq 0x7200a(%rip), %rcx # 0x8ee20
movq %rcx, (%rdi)
movq 0x8(%rdi), %rdi
addq $0x18, %rax
cmpq %rax, %rdi
je 0x1ce31
movq (%rax), %rsi
incq %rsi
jmp 0x12570
retq
| /olegtarasov[P]fastText/src/catch.hpp |
Catch::listTestsNamesOnly(Catch::Config const&) | std::size_t listTestsNamesOnly( Config const& config ) {
TestSpec const& testSpec = config.testSpec();
std::size_t matchedTests = 0;
std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
for( auto const& testCaseInfo : matchedTestCases... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
callq 0x3fe58
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x18(%rcx)
leaq 0x10(%rsp), %r15
movq %r15, %r... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::Matchers::Floating::WithinRelMatcher::WithinRelMatcher(double, double) | WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
m_target(target),
m_epsilon(epsilon){
CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon < 0 does not make sense.");
CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x6ff91(%rip), %rax # 0x8eef8
movq %rax, (%rdi)
leaq 0x6ffb7(%rip), %rax # 0x8ef28
movq %rax, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movsd %xmm1, 0x38(%rdi)
x... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::Matchers::WithinULP(double, unsigned long) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
} | movq %rdi, %rax
leaq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x6fc66(%rip), %rcx # 0x8eeb0
movq %rcx, (%rdi)
leaq 0x6fc8c(%rip), %rcx # 0x8eee0
movq %rcx, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movq %rsi, 0x38(%rdi)
movb $0x1, 0x40(%rdi)
retq
| /olegtarasov[P]fastText/src/catch.hpp |
Catch::Matchers::Generic::Detail::finalizeDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
if (desc.empty()) {
return "matches undescribed predicate";
} else {
return "matches predicate: \"" + desc + '"';
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x1f33f
movq %rsi, %rdx
leaq 0x4afd8(%rip), %rsi # 0x6a2cf
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x425af
movq 0x8(%r14), %rsi
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
movl $0x22, %r8d
callq 0x12a30
leaq 0x10(%rbx), %rdx
movq ... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::Matchers::StdString::CasedString::adjustString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string CasedString::adjustString( std::string const& str ) const {
return m_caseSensitivity == CaseSensitive::No
? toLower( str )
: str;
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jne 0x1f3f6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1df4c
jmp 0x1f40f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4e742
movq %rbx, %rax
popq %rbx
retq
| /olegtarasov[P]fastText/src/catch.hpp |
Catch::Matchers::StdString::EqualsMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool EqualsMatcher::match( std::string const& source ) const {
return m_comparator.adjustString( source ) == m_comparator.m_str;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1f3e0
movq 0x8(%r14), %rdx
cmpq 0x40(%rbx), %rdx
jne 0x1f7c4
testq %rdx, %rdx
je 0x1f7c8
movq 0x38(%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0x125b0
testl %eax, %eax
sete %bl
jmp 0x1f7c... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::Matchers::StdString::ContainsMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool ContainsMatcher::match( std::string const& source ) const {
return contains( m_comparator.adjustString( source ), m_comparator.m_str );
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1f3e0
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x12980
movq %rax, %rbx
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1f8e5
mov... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::Matchers::StdString::RegexMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | bool RegexMatcher::match(std::string const& matchee) const {
auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
if (m_caseSensitivity == CaseSensitive::Choice::No) {
flags |= std::regex::icase;
}
auto reg = std::regex(m_... | pushq %r14
pushq %rbx
subq $0x48, %rsp
xorl %edx, %edx
cmpl $0x1, 0x50(%rdi)
movq %rsi, %rbx
sete %dl
orl $0x10, %edx
leaq 0x30(%rdi), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x426b6
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0,... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::Generators::GeneratorTracker::~GeneratorTracker() | GeneratorTracker::~GeneratorTracker() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x6e2e9(%rip), %rax # 0x8f120
movq %rax, (%rdi)
leaq 0x6e387(%rip), %rax # 0x8f1c8
movq %rax, 0x68(%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x20e54
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x70(%rbx)
leaq 0x6e5cd(%rip), %rax # 0x8f430
movq %rax, (%rbx)
leaq 0x48(%... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::RunContext::RunContext(std::shared_ptr<Catch::IConfig const> const&, std::unique_ptr<Catch::IStreamingReporter, std::default_delete<Catch::IStreamingReporter>>&&) | RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
: m_runInfo(_config->name()),
m_context(getCurrentMutableContext()),
m_config(_config),
m_reporter(std::move(reporter)),
m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x6e30e(%rip), %rax # 0x8f200
movq %rax, (%rdi)
leaq 0x6e3c4(%rip), %rax # 0x8f2c0
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x20(%ra... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::RunContext::assertionEnded(Catch::AssertionResult const&) | void RunContext::assertionEnded(AssertionResult const & result) {
if (result.getResultType() == ResultWas::Ok) {
m_totals.assertions.passed++;
m_lastAssertionPassed = true;
} else if (!result.isOk()) {
m_lastAssertionPassed = false;
if( m_activeTestCase->g... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x88(%rsi), %eax
testl %eax, %eax
je 0x221c2
testb $0x10, %al
je 0x221c9
movl 0x30(%rbx), %eax
andl $0x8, %eax
jne 0x221c9
movb $0x0, 0x1e9(%r14)
movq 0x38(%r14), %rax
testb $0xc, 0xa0(%rax)
je 0x22295
incq 0x10... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::RunContext::sectionEnded(Catch::SectionEndInfo const&) | void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
Counts assertions = m_totals.assertions - endInfo.prevAssertions;
bool missingAssertions = testForMissingAssertions(assertions);
if (!m_activeSections.empty()) {
m_activeSections.back()->close();
m_activeSec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movdqu 0xf8(%rdi), %xmm0
movdqu 0x50(%r14), %xmm1
psubq %xmm1, %xmm0
movdqa %xmm0, (%rsi)
movq 0x108(%rdi), %rax
subq 0x60(%r14), %rax
mov... | /olegtarasov[P]fastText/src/catch.hpp |
Catch::RunContext::handleUnexpectedInflightException(Catch::AssertionInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::AssertionReaction&) | void RunContext::handleUnexpectedInflightException(
AssertionInfo const& info,
std::string const& message,
AssertionReaction& reaction
) {
m_lastAssertionInfo = info;
AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
data.mes... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x30(%rsi), %eax
movl %eax, 0x190(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x180(%rdi)
movups %xmm1, 0x170(%rdi)
movups %xmm0, 0x160(%rdi)
leaq 0... | /olegtarasov[P]fastText/src/catch.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.