name string | code string | asm string | file string |
|---|---|---|---|
enableCursor | static void enableCursor(_GLFWwindow* window)
{
if (window->rawMouseMotion)
disableRawMouseMotion(window);
_glfw.x11.disabledCursorWindow = NULL;
XUngrabPointer(_glfw.x11.display, CurrentTime);
_glfwPlatformSetCursorPos(window,
_glfw.x11.restoreCursorPosX,
... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x1f8(%rdi)
je 0x14c27
leaq 0x7(%rsp), %rax
movb $0x0, (%rax)
movabsq $0x100000001, %rcx # imm = 0x100000001
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x2b602(%rip), %rax # 0x40210
movq 0x20640(%rax), %rdi
movq 0x20650(%ra... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
updateCursorImage | static void updateCursorImage(_GLFWwindow* window)
{
if (window->cursorMode == GLFW_CURSOR_NORMAL)
{
if (window->cursor)
{
XDefineCursor(_glfw.x11.display, window->x11.handle,
window->cursor->x11.handle);
}
else
XUndefineCursor(_g... | cmpl $0x34001, 0x7c(%rdi) # imm = 0x34001
jne 0x14ca4
movq 0x50(%rdi), %rcx
leaq 0x2b58b(%rip), %rax # 0x40210
movq 0x20640(%rax), %rax
movq 0x350(%rdi), %rsi
testq %rcx, %rcx
je 0x14cc5
movq 0x8(%rcx), %rdx
movq %rax, %rdi
jmp 0x7a40
leaq 0x2b565(%rip), %rax # 0x40210
movq 0x350(%rdi), %rsi
movq 0x20640(%ra... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetScancodeName | const char* _glfwPlatformGetScancodeName(int scancode)
{
if (!_glfw.x11.xkb.available)
return NULL;
if (scancode < 0 || scancode > 0xff ||
_glfw.x11.keycodes[scancode] == GLFW_KEY_UNKNOWN)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid scancode %i", scancode);
return NULL;
... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x2b537(%rip), %r14 # 0x40210
cmpl $0x0, 0x21488(%r14)
je 0x14d59
movl %edi, %eax
cmpl $0xff, %edi
ja 0x14d5d
movl %eax, %ecx
movswq 0x20d6a(%r14,%rcx,2), %r15
cmpq $-0x1, %r15
je 0x14d5d
movq 0x20640(%r14), %rdi
movl 0x214a4(%r14), %edx
movzbl %al, %esi
xorl %ebx, %ebx
xorl %e... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
getSelectionString | static const char* getSelectionString(Atom selection)
{
char** selectionString = NULL;
const Atom targets[] = { _glfw.x11.UTF8_STRING, XA_STRING };
const size_t targetCount = sizeof(targets) / sizeof(targets[0]);
if (selection == _glfw.x11.PRIMARY)
selectionString = &_glfw.x11.primarySelectionS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rsi
leaq 0x2b316(%rip), %r14 # 0x40210
movq 0x213b8(%r14), %rax
movq %rax, 0x30(%rsp)
xorl %eax, %eax
cmpq %rdi, 0x21398(%r14)
movq $0x1f, 0x38(%rsp)
setne %al
leaq 0x20688(,%rax,8), %rbp
movq 0x... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetRequiredInstanceExtensions | void _glfwPlatformGetRequiredInstanceExtensions(char** extensions)
{
if (!_glfw.vk.KHR_surface)
return;
if (!_glfw.vk.KHR_xcb_surface || !_glfw.x11.x11xcb.handle)
{
if (!_glfw.vk.KHR_xlib_surface)
return;
}
extensions[0] = "VK_KHR_surface";
// NOTE: VK_KHR_xcb_surf... | leaq 0x2b046(%rip), %rcx # 0x40210
cmpl $0x0, 0x20620(%rcx)
je 0x151f8
movl 0x20628(%rcx), %eax
testl %eax, %eax
setne %dl
cmpq $0x0, 0x21528(%rcx)
setne %sil
testb %sil, %dl
jne 0x151f9
cmpl $0x0, 0x20624(%rcx)
jne 0x151f9
retq
leaq 0x1f788(%rip), %rdx # 0x34988
movq %rdx, (%rdi)
cmpq $0x0, 0x21528(%rcx)
leaq ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetPhysicalDevicePresentationSupport | int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
VkPhysicalDevice device,
uint32_t queuefamily)
{
VisualID visualID = XVisualIDFromVisual(DefaultVisual(_glfw.x11.display,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x2afd0(%rip), %r13 # 0x40210
movq 0x20640(%r13), %rax
movq 0xe8(%rax), %rax
movslq 0x20648(%r13), %rcx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rdi
callq 0x79d0
movq %rax, %r15
cmpl $0x0, 0x20628(%r13)
movq 0x... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwSetX11SelectionString | GLFWAPI void glfwSetX11SelectionString(const char* string)
{
_GLFW_REQUIRE_INIT();
free(_glfw.x11.primarySelectionString);
_glfw.x11.primarySelectionString = _glfw_strdup(string);
XSetSelectionOwner(_glfw.x11.display,
_glfw.x11.PRIMARY,
_glfw.x11.helperWin... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x2ad21(%rip), %r14 # 0x40210
cmpl $0x0, (%r14)
je 0x15553
movq %rdi, %rbx
movq 0x20688(%r14), %rdi
callq 0x76c0
movq %rbx, %rdi
callq 0x8b0a
movq %rax, 0x20688(%r14)
movq 0x21398(%r14), %rsi
movq 0x20640(%r14), %rdi
movq 0x20660(%r14), %rdx
xorl %ecx, %ecx
callq 0x7600
movq 0x... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
convertLatin1toUTF8 | static char* convertLatin1toUTF8(const char* source)
{
size_t size = 1;
const char* sp;
for (sp = source; *sp; sp++)
size += (*sp & 0x80) ? 2 : 1;
char* target = calloc(size, 1);
char* tp = target;
for (sp = source; *sp; sp++)
tp += _glfwEncodeUTF8(tp, *sp);
return ta... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x1578f
leaq 0x1(%rbx), %rax
movl $0x1, %edi
xorl %edx, %edx
testb %cl, %cl
setns %dl
subq %rdx, %rdi
addq $0x2, %rdi
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x15776
jmp 0x15794
movl $0x1, %edi
movl $0x1, %esi
callq 0x7380
movq %r... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.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 0x15a07
movq %rdi, %r14
addq $0x8, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x7840
testl %eax, %eax
je 0x159f1
leaq 0x225a9(%rip), %rsi # 0x37f8c
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x8b57
jmp 0x159fd
movl $0x1, (%r14)
movl $0x1... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/posix_thread.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 0x2a246(%rip), %rax # 0x40210
movq 0x21660(%rax), %rcx
testq %rcx, %rcx
jne 0x15fe2
movq 0x21668(%rax), %rcx
testq %rcx, %rcx
je 0x15fe7
movq %rsi, %rdi
jmpq *%rcx
movq 0x215f0(%rax), %rdi
jmp 0x7580
| /apitrace[P]apitrace-tests/thirdparty/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 $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x29daf(%rip), %r14 # 0x40210
movq 0x20640(%r14), %rdi
movl $0x1, %esi
callq *0x21608(%r14)
testq %rax, %rax
je 0x16491
leaq 0x2219a(%rip), %rsi # 0x3861a
movq %rax, %rdi
callq 0x7770
testl %e... | /apitrace[P]apitrace-tests/thirdparty/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 0x299b7(%rip), %rcx # 0x40210
movq 0x21628(%rcx), %rax
movq 0x20640(%rcx), %rdi
testq %rbx, %rbx
je 0x16889
movq 0x278(%rbx), %rdx
movq 0x280(%rbx), %rsi
callq *%rax
testl %eax, %eax
jne 0x16893
leaq 0x21dba(%rip), %rsi # 0x38641
jmp 0x168af
xorl %esi, %esi
xorl %edx, %edx
callq ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
swapIntervalGLX | static void swapIntervalGLX(int interval)
{
_GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (_glfw.glx.EXT_swap_control)
{
_glfw.glx.SwapIntervalEXT(_glfw.x11.display,
window->context.glx.window,
interval);
}
... | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x29926(%rip), %r14 # 0x40210
leaq 0x2059c(%r14), %rdi
callq 0x15965
movq %r14, %rdx
cmpl $0x0, 0x21694(%r14)
je 0x16923
movq 0x21678(%rdx), %rcx
movq 0x20640(%rdx), %rdi
movq 0x280(%rax), %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
cmpl ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
glfwChooseVisualGLX | GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
GLXFBConfig native;
XVisualInfo* result;
if (!chooseGLXFBCo... | pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rdi
movq %rsp, %rsi
callq 0x16446
testl %eax, %eax
je 0x16a0b
leaq 0x29835(%rip), %rax # 0x40210
movq 0x20640(%rax), %rdi
movq (%rsp), %rsi
callq *0x21648(%rax)
testq %rax, %rax
je 0x16a1b
movq (%rax), %rcx
movq %rcx, (%r14)
movl 0x14(%rax)... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
glfwGetGLXWindow | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (window->context.source != GLFW_NATIVE_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return None;
}
return window->contex... | pushq %rbx
leaq 0x2978e(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x16a9c
cmpl $0x36001, 0x204(%rdi) # imm = 0x36001
jne 0x16aa5
movq 0x280(%rdi), %rbx
jmp 0x16ab5
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x16aac
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_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 0x29351(%rip), %rbx # 0x40210
movq 0x21710(%rbx), %rdi
testq %rdi, %rdi
je 0x16edc
callq *0x21770(%rbx)
movq $0x0, 0x21710(%rbx)
movq 0x21740(%rbx), %rdi
testq %rdi, %rdi
je 0x16ef8
callq 0x7410
movq $0x0, 0x21740(%rbx)
popq %rbx
retq
| /apitrace[P]apitrace-tests/thirdparty/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";
... | addl $0xffffd000, %edi # imm = 0xFFFFD000
cmpl $0xe, %edi
ja 0x16f16
movl %edi, %eax
leaq 0x22002(%rip), %rcx # 0x38f10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x21f20(%rip), %rax # 0x38e3d
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/egl_context.c |
chooseEGLConfig | static GLFWbool chooseEGLConfig(const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* desired,
EGLConfig* result)
{
EGLConfig* nativeConfigs;
_GLFWfbconfig* usableConfigs;
const _GLFWfbconfig* closest;
int i, nativeCount, usableCount;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, 0x28(%rsp)
leaq 0x28d7f(%rip), %r14 # 0x40210
movq 0x21710(%r14), %rdi
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x21750(%r14)
movslq ... | /apitrace[P]apitrace-tests/thirdparty/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 0x289d2(%rip), %r14 # 0x40210
movq 0x21710(%r14), %rdi
movq 0x217a0(%r14), %rax
testq %rbx, %rbx
je 0x1787f
movq 0x290(%rbx), %rcx
movq 0x298(%rbx), %rdx
movq %rdx, %rsi
callq *%rax
testl %eax, %eax
jne 0x1788b
callq *0x21760(%r14)
movl %eax, %edi
callq 0x16efa
... | /apitrace[P]apitrace-tests/thirdparty/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 $0x2059c, %edi # imm = 0x2059C
addq 0x27681(%rip), %rdi # 0x3efc8
callq 0x15965
movq 0x2a0(%rax), %rdi
testq %rdi, %rdi
je 0x17967
movq %rbx, %rsi
callq 0x7580
testq %rax, %rax
je 0x17967
popq %rbx
retq
leaq 0x288a2(%rip), %rax # 0x40210
movq %rbx, %rdi
popq %rbx
jmpq *0... | /apitrace[P]apitrace-tests/thirdparty/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, 0x200(%rdi) # imm = 0x30001
je 0x179a4
movq 0x2a0(%rbx), %rdi
testq %rdi, %rdi
je 0x179a4
callq 0x7410
movq $0x0, 0x2a0(%rbx)
movq 0x298(%rbx), %rsi
testq %rsi, %rsi
je 0x179cf
leaq 0x28859(%rip), %rax # 0x40210
movq 0x21710(%rax), %rdi
callq *0x21788(%rax)
movq $0x0, 0x2... | /apitrace[P]apitrace-tests/thirdparty/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %rdi
xorl %ebp, %ebp
movl %ebp, 0x4(%rsp)
movl %ebp, (%rsp)
leaq 0x8(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1746e
testl %eax, %eax
je 0x17aa2
leaq 0x287db(%rip), %r12 # 0x40210
movq 0x21710... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/egl_context.c |
glfwGetEGLContext | GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_CONTEXT);
if (window->context.source != GLFW_EGL_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_CONTEXT;
}
re... | pushq %rbx
leaq 0x28709(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x17b21
cmpl $0x36002, 0x204(%rdi) # imm = 0x36002
jne 0x17b2a
movq 0x290(%rdi), %rbx
jmp 0x17b3a
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x17b31
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi... | /apitrace[P]apitrace-tests/thirdparty/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.source != GLFW_EGL_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_SURFACE;
}
re... | pushq %rbx
leaq 0x286c9(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x17b61
cmpl $0x36002, 0x204(%rdi) # imm = 0x36002
jne 0x17b6a
movq 0x298(%rdi), %rbx
jmp 0x17b7a
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x17b71
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/egl_context.c |
glfwCreateContextOSMesa | GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
OSMesaContext share = NULL;
const int accumBits = fbconfig->accumRedBits +
fbconfig->accumGreenBi... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
cmpl $0x30002, (%rsi) # imm = 0x30002
jne 0x17d88
leaq 0x212cd(%rip), %rsi # 0x39049
xorl %ebp, %ebp
movl $0x10006, %edi # imm = 0x10006
jmp 0x17f48
movq %rdi, %rbx
movl 0x1c(%rdx), %ecx
addl 0x18(%rdx), %ecx
addl 0x20(%rdx), %ecx
movq 0x28(%rsi), %r... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/osmesa_context.c |
makeContextCurrentOSMesa | static void makeContextCurrentOSMesa(_GLFWwindow* window)
{
if (window)
{
int width, height;
_glfwPlatformGetFramebufferSize(window, &width, &height);
// Check to see if we need to allocate a new buffer
if ((window->context.osmesa.buffer == NULL) ||
(width != window-... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1800a
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x126b0
movq 0x2b8(%rbx), %rdi
testq %rdi, %rdi
je 0x17fa8
movl 0xc(%rsp), %eax
cmpl 0x2b0(%rbx), %eax
jne 0x17fa8
movl 0x8(%rsp), %eax
cmpl 0x2b4(%rbx), %eax
je ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/osmesa_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 0x18167
leaq 0x28160(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x1812c
cmpl $0x36003, 0x204(%rdi) # imm = 0x36003
jne 0x18136
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x2a8(%rdi), %rdi
leaq 0xc(%rsp), %rsi... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/osmesa_context.c |
glfwGetOSMesaDepthBuffer | GLFWAPI int glfwGetOSMesaDepthBuffer(GLFWwindow* handle,
int* width, int* height,
int* bytesPerValue,
void** buffer)
{
void* mesaBuffer;
GLint mesaWidth, mesaHeight, mesaBytes;
_GLFWwindow* window ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x18258
leaq 0x2806f(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x1821d
cmpl $0x36003, 0x204(%rdi) # imm = 0x36003
jne 0x18227
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x2a8(%rdi), %rdi
leaq 0xc(%rsp), %rsi... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/osmesa_context.c |
glfwGetOSMesaContext | GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.source != GLFW_OSMESA_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window... | pushq %rbx
leaq 0x27f91(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x18299
cmpl $0x36003, 0x204(%rdi) # imm = 0x36003
jne 0x182a2
movq 0x2a8(%rdi), %rbx
jmp 0x182b2
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x182a9
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/osmesa_context.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 $0x408, %r14d # imm = 0x408
leaq 0x2793e(%rip), %rbx # 0x40210
cmpl $0x0, (%rbx,%r14)
je 0x188e2
leaq (%rbx,%r14), %rdi
callq 0x18931
addq $0x2018, %r14 # imm = 0x2018
cmpq $0x20588, %r14 # imm = 0x20588
jne 0x188d2
leaq 0x216c8(%rbx), %rdi
callq 0x... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/linux_joystick.c |
glfwDetectJoystickConnectionLinux | void _glfwDetectJoystickConnectionLinux(void)
{
if (_glfw.linjs.inotify <= 0)
return;
ssize_t offset = 0;
char buffer[16384];
const ssize_t size = read(_glfw.linjs.inotify, buffer, sizeof(buffer));
while (size > offset)
{
regmatch_t match;
const struct inotify_event* e ... | leaq 0x278b3(%rip), %rax # 0x40210
movl 0x216c0(%rax), %edi
testl %edi, %edi
jle 0x18ab8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5028, %rsp # imm = 0x5028
leaq 0x1020(%rsp), %rsi
movl $0x4000, %edx # imm = 0x4000
callq 0x77d0
testq %rax, %rax
jle 0x18aa7
movq %r... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/linux_joystick.c |
glfwPlatformPollJoystick | int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
{
// Read all queued events (non-blocking)
for (;;)
{
struct input_event e;
errno = 0;
if (read(js->linjs.fd, &e, sizeof(e)) < 0)
{
// Reset the joystick slot if the device was disconnected
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x7050
movq %rax, %r14
movq %rsp, %r15
leaq 0x27734(%rip), %r13 # 0x40210
movl $0x0, (%r14)
movl 0xf0(%rbx), %edi
movl $0x18, %edx
movq %r15, %rsi
callq 0x77d0
movq %rax, %r12
testq %rax, %rax
js 0x18b3b
movzwl ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/linux_joystick.c |
pollAbsState | static void pollAbsState(_GLFWjoystick* js)
{
for (int 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;
h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x19f4, %r12d # imm = 0x19F4
movl $0x18f4, %r13d # imm = 0x18F4
movl $0x80184540, %ebp # imm = 0x80184540
xorl %r14d, %r14d
cmpl $0x0, (%rbx,%r13)
js 0x18bfe
leaq (%rbx,%r12), %r15
movl 0xf0(%rbx),... | /apitrace[P]apitrace-tests/thirdparty/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 0x18f4(%rdi,%rcx,4), %esi
movl %ecx, %r8d
andl $-0x8, %r8d
cmpl $0x10, %r8d
jne 0x18c5b
leal -0x10(%rax), %ecx
shrl %ecx
andl $0x1, %eax
leaq (%rdi,%rcx,8), %rcx
addq $0x1ff4, %rcx # imm = 0x1FF4
movl %eax, %eax
testl %edx, %edx
je 0x18c9d
js 0x18ca6
movl $0x2, (%rcx,%ra... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/linux_joystick.c |
QtMWidgets::SliderPrivate::pixelPosToRangeValue(int) const | int
SliderPrivate::pixelPosToRangeValue( int p ) const
{
const QRect gr = grooveRect();
int sliderMin = 0, sliderMax = 0;
if( q->orientation() == Qt::Horizontal )
{
sliderMin = gr.x();
sliderMax = gr.right() - 2 * radius;
}
else
{
sliderMin = gr.y();
sliderMax = gr.bottom() - 2 * radius;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x4c53e
movq %rax, %rbp
movq %rdx, %r13
movq (%r14), %rdi
callq 0x4a840
movq %rbp, %r12
shrq $0x20, %r12
movq %r13, %r15
shrq $0x20, %r15
cmpl $0x1, %eax
cmovel %r13d, %r15d
movl 0x8(%r14), %eax
movq %rax,... | /igormironchik[P]qtmwidgets/src/slider.cpp |
QtMWidgets::ToolBar::_q_leftArrowClicked() | void
ToolBar::_q_leftArrowClicked()
{
int delta = 0;
if( d->layout->orientation() == Qt::Horizontal )
delta = - d->iconSize.width() - d->layout->spacing();
else
delta = - d->iconSize.height() - d->layout->spacing();
d->layout->setOffset( delta );
update();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rdi
xorl %ecx, %ecx
cmpl $0x1, 0x48(%rdi)
setne %cl
movq (%rdi), %rdx
movl 0x8(%rax,%rcx,4), %ebp
callq *0x60(%rdx)
addl %ebp, %eax
movq 0x28(%rbx), %rcx
movq 0x10(%rcx), %rdi
subl %eax, 0x50(%rdi)
callq 0x4ba50
movq %rbx, %rdi
add... | /igormironchik[P]qtmwidgets/src/toolbar.cpp |
negamax(int, int, int) | static inline int negamax(int alpha, int beta, int depth) {
// initializing length of current variation
pvLength[ply] = ply;
int score;
int bestMove = 0;
int hashFlag = ALPHA;
if ((ply && isRepetition()) || fiftyRuleCounter >= 100) {
// if repetition is found \ 50 move rule found -> ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4e8, %rsp # imm = 0x4E8
movl %edx, %r15d
movl %esi, %r14d
movl %edi, 0xc(%rsp)
leaq 0xd152(%rip), %rax # 0x13a24
movslq (%rax), %rsi
leaq 0x250214(%rip), %rax # 0x256af0
movl %esi, (%rax,%rsi,4)
testq %rsi, %rsi
je 0x692a
leaq ... | /yodatk[P]NiCimEngine/src/NegaMaxSearch.h |
sortMoves(moves*, int) | static inline int sortMoves(moves *moveList,int bestMove) {
int moveScores[moveList->count];
for (int i = 0; i < moveList->count; i++) {
// if best move -> give A LOT of score
if(bestMove == moveList->moves[i]){
moveScores[i] = 30000;
}
else{
// for each m... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x400(%rdi), %eax
movq %rsp, %rdx
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
subq %rcx, %rdx
movq %rdx, %rsp
leaq 0x25246b(%rip), %rcx # 0x25abf4
movl (%rcx), %r10d
leaq 0x9335(%rip), %rcx # 0x11ac8
xorl %r11d... | /yodatk[P]NiCimEngine/src/Search.h |
open_file(char const*) | FD open_file(const char *name)
{
#ifndef _WIN32
return open(name, O_RDONLY);
#else
return CreateFile(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
FILE_FLAG_RANDOM_ACCESS, NULL);
#endif
} | xorl %esi, %esi
xorl %eax, %eax
jmp 0x21f0
| /yodatk[P]NiCimEngine/src/nnue/misc.cpp |
ApprovalTests::Options::withNamer(std::shared_ptr<ApprovalTests::ApprovalNamer>) | Options Options::withNamer(std::shared_ptr<ApprovalNamer> namer)
{
return Options(
fileOptions_, scrubber_, reporter_, usingDefaultScrubber_, std::move(namer));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
callq 0x17a7c
leaq 0x28(%r15), %rsi
leaq 0x40(%rsp), %rdi
callq 0x17a90
movq 0x48(%r15), %rcx
movzbl 0x60(%r15), %r8d
leaq 0x8(%rsp), %r15
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movaps %xmm0, -0x8(... | /approvals[P]ApprovalTests/ApprovalTests/core/Options.cpp |
ApprovalFileLog::initialize() | void ApprovalFileLog::initialize()
{
static bool isInitialized{false};
if (isInitialized)
{
return;
}
isInitialized = true;
ApprovalTests::FileUtils::writeToFile(getLogFilePath(), "");
} | pushq %rbx
subq $0x50, %rsp
cmpb $0x0, 0x90f9c(%rip) # 0xa8af0
jne 0x17ba0
movb $0x1, 0x90f93(%rip) # 0xa8af0
leaq 0x30(%rsp), %rdi
callq 0x17bca
leaq 0x55273(%rip), %rsi # 0x6cde1
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x15250
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2ae98
leaq 0x10(%r... | /approvals[P]ApprovalTests/ApprovalTests/logs/ApprovalFileLog.cpp |
ApprovalTests::TestName::checkBuildConfiguration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void TestName::checkBuildConfiguration(const std::string& fileName)
{
if (checkBuildConfig_ && !FileUtils::fileExists(fileName))
{
throw std::runtime_error(getMisconfiguredBuildHelp(fileName));
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x908af(%rip) # 0xa8638
jne 0x17d97
movq %rdi, %r14
callq 0x2ab80
testb %al, %al
je 0x17da0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x15310
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x182ac
movb $0x1, %b... | /approvals[P]ApprovalTests/ApprovalTests/namers/ApprovalTestNamer.cpp |
ApprovalTests::TestName::setFileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void TestName::setFileName(const std::string& file)
{
originalFileName = file;
fileName = file.empty() ? handleBoostQuirks() : findFileName(file);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x15360
cmpq $0x0, 0x8(%r14)
je 0x17e40
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x17e90
jmp 0x17e4a
leaq 0x8(%rsp), %rdi
callq 0x17e6e
addq $0x18, %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x157c0
movq... | /approvals[P]ApprovalTests/ApprovalTests/namers/ApprovalTestNamer.cpp |
ApprovalTests::TestName::registerRootDirectoryFromMainFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool TestName::registerRootDirectoryFromMainFile(const std::string& file)
{
std::cout << "TestName::registerRootDirectoryFromMainFile from __FILE__ " << file
<< '\n';
if (file.empty())
{
throw std::runtime_error("Cannot register an empty path as root directory"... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8feb7(%rip), %rdi # 0xa7f98
leaq 0x4d3a2(%rip), %rsi # 0x6548a
callq 0x15630
movq %rax, %rdi
movq %rbx, %rsi
callq 0x155a0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x15770
cmpq $0x0, 0x8(%rbx)
je 0x181bf
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0... | /approvals[P]ApprovalTests/ApprovalTests/namers/ApprovalTestNamer.cpp |
ApprovalTests::ApprovalTestNamer::getTestName[abi:cxx11]() const | std::string ApprovalTestNamer::getTestName() const
{
std::stringstream ext;
auto test = getCurrentTest();
for (size_t i = 0; i < test.sections.size(); i++)
{
if (0 < i)
{
ext << ".";
}
ext << test.sections[i];
}
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movq %rdi, %rbx
leaq 0x78(%rsp), %rdi
callq 0x15480
callq 0x18430
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x18c54
leaq 0x88(%rsp), %r14
xorl %r12d, %r12d
leaq 0x54aab(%rip), %r15 # 0x6ce1a
xorl %r13d, %r13d
movq 0x... | /approvals[P]ApprovalTests/ApprovalTests/namers/ApprovalTestNamer.cpp |
ApprovalTests::ApprovalTestNamer::getFullFileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string
ApprovalTestNamer::getFullFileName(const std::string& approved,
const std::string& extensionWithDot) const
{
std::stringstream ext;
ext << getDirectory() << getOutputFileBaseName() << approved << extensionWithDot;
return ext.str();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x15480
leaq 0x20(%rsp), %rdi
callq 0x18956
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x155a0
movq %rax, %r12
movq %rsp, %rdi
callq 0x18b6a
movq %rsp... | /approvals[P]ApprovalTests/ApprovalTests/namers/ApprovalTestNamer.cpp |
ApprovalTests::DefaultNamerFactory::defaultNamer() | NamerCreator& DefaultNamerFactory::defaultNamer()
{
static NamerCreator namer = []() {
return std::make_shared<ApprovalTestNamer>();
};
return namer;
} | movb 0x8fd4a(%rip), %al # 0xa8b98
testb %al, %al
je 0x18e5a
leaq 0x8fd1f(%rip), %rax # 0xa8b78
retq
pushq %rax
leaq 0x8fd36(%rip), %rdi # 0xa8b98
callq 0x15af0
testl %eax, %eax
je 0x18eb7
xorps %xmm0, %xmm0
movups %xmm0, 0x8fd03(%rip) # 0xa8b78
leaq 0x8fcfc(%rip), %rsi # 0xa8b78
leaq 0x73(%rip), %ra... | /approvals[P]ApprovalTests/ApprovalTests/namers/DefaultNamerFactory.cpp |
ApprovalTests::Linux::LinuxDiffReporter::LinuxDiffReporter() | LinuxDiffReporter::LinuxDiffReporter()
: FirstWorkingReporter({
// begin-snippet: linux_diff_reporters
new BeyondCompareReporter(),
new MeldReporter(),
new SublimeMergeReporter(),
new KDiff3Reporter()
... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
pushq $0x70
popq %rdi
callq 0x15640
movq %rax, %r14
movq %rax, %rdi
callq 0x1af2a
movq %r14, 0x28(%rsp)
pushq $0x70
popq %rdi
callq 0x15640
movq %rax, %r14
movq %rax, %rdi
callq 0x1aedc
movq %r14, 0x30(%rsp)
pushq $0x20
popq %rdi
callq 0x15640
movq %rax, %r14
movq ... | /approvals[P]ApprovalTests/ApprovalTests/reporters/LinuxReporters.cpp |
ApprovalTests::ReporterFactory::createMap[abi:cxx11]() | ReporterFactory::Reporters ReporterFactory::createMap()
{
Reporters map;
APPROVAL_TESTS_REGISTER_REPORTER(AutoApproveIfMissingReporter);
APPROVAL_TESTS_REGISTER_REPORTER(AutoApproveReporter);
APPROVAL_TESTS_REGISTER_REPORTER(CIBuildOnlyReporter);
APPROVAL_TESTS_REGISTER_REPO... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x4b0f1(%rip), %rsi # 0x6689e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x15250
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
c... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ReporterFactory.cpp |
ApprovalTests::ReporterFactory::createReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::unique_ptr<Reporter>
ReporterFactory::createReporter(const std::string& reporterName) const
{
auto osPrefix = getOsPrefix();
auto key = findReporterName(osPrefix, reporterName);
if (!key.empty())
{
return map.at(key)();
}
return std::unique_ptr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x1b728
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x1c700
cmpq $0x0, 0x10(%rsp)
je 0x1c6b4
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq ... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ReporterFactory.cpp |
ApprovalTests::ReporterFactory::findReporterName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string ReporterFactory::findReporterName(const std::string& osPrefix,
const std::string& reporterName) const
{
auto trimmedReporterName = StringUtils::trim(reporterName);
trimmedReporterName = StringUtils::toLower(trimmedReporterName);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
leaq 0x1b8(%rsp), %rbx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x15860
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x2b3be
leaq 0x1b8(%rsp), %rdi
callq 0x15c18
leaq ... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ReporterFactory.cpp |
ApprovalTests::TextDiffReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool TextDiffReporter::report(std::string received, std::string approved) const
{
stream_ << "Comparing files:" << std::endl;
stream_ << "received: " << received << std::endl;
stream_ << "approved: " << approved << std::endl;
const bool result = m_reporter->report(received, approved)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x49384(%rip), %rsi # 0x67458
callq 0x15630
movq %rax, %rdi
callq 0x15300
movq 0x10(%rbx), %rdi
leaq 0x4937d(%rip), %rsi # 0x67469
callq 0x15630
movq %rax, %rdi
movq... | /approvals[P]ApprovalTests/ApprovalTests/reporters/TextDiffReporter.cpp |
ApprovalTests::Windows::WindowsDiffReporter::WindowsDiffReporter() | WindowsDiffReporter::WindowsDiffReporter()
: FirstWorkingReporter({
// begin-snippet: windows_diff_reporters
new TortoiseDiffReporter(), // Note that this uses Tortoise SVN Diff
new TortoiseGitDiffReporter(),
new BeyondCompareReporter()... | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x15640
movq %rax, %r14
movq %rax, %rdi
callq 0x1e4f8
movq %r14, 0x20(%rsp)
pushq $0x20
popq %rdi
callq 0x15640
movq %rax, %r14
movq %rax, %rdi
callq 0x1e636
movq %r14, 0x28(%rsp)
pushq $0x20
popq %rdi
callq 0x15640
movq %rax, %r14
movq ... | /approvals[P]ApprovalTests/ApprovalTests/reporters/WindowsReporters.cpp |
ApprovalTests::Windows::WindowsDiffReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool WindowsDiffReporter::report(std::string received, std::string approved) const
{
if (!SystemUtils::isWindowsOs())
{
return false;
}
return FirstWorkingReporter::report(received, approved);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2b550
testb %al, %al
je 0x1ea27
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x15860
movq %rsp, %rdi
movq %r14, %rsi
callq 0x15860
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1a488
movl %eax, %ebx
... | /approvals[P]ApprovalTests/ApprovalTests/reporters/WindowsReporters.cpp |
ApprovalTests::Scrubbers::createRegexScrubber(std::__cxx11::basic_regex<char, std::__cxx11::regex_traits<char>> const&, std::function<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> (std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::ch... | Scrubber createRegexScrubber(const std::regex& regexPattern,
const RegexReplacer& replacer)
{
return [=](const std::string& input) {
return scrubRegex(input, regexPattern, replacer);
};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x1f392
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f3c8
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
pushq $0x40
popq %rdi
callq 0x15640
movq %rax, %r15
movq %rsp, %rsi
movq %r... | /approvals[P]ApprovalTests/ApprovalTests/scrubbers/Scrubbers.cpp |
ApprovalTests::Scrubbers::scrubGuid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string scrubGuid(const std::string& input)
{
static const std::regex regex("[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-["
"0-9a-fA-F]{4}-[0-9a-fA-F]{12}");
int matchNumber = 0;
std::map<std::string, int> matchIndices;
... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x89c62(%rip), %al # 0xa8c50
testb %al, %al
je 0x1f06c
leaq 0x4(%rsp), %rax
andl $0x0, (%rax)
leaq 0x30(%rsp), %rcx
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
leaq 0x28(%rsp), %... | /approvals[P]ApprovalTests/ApprovalTests/scrubbers/Scrubbers.cpp |
ApprovalTests::FileUtils::readFileThrowIfMissing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string FileUtils::readFileThrowIfMissing(const std::string& fileName)
{
std::ifstream in(fileName.c_str(), std::ios_base::in);
if (!in)
{
throw std::runtime_error("File does not exist: " + fileName);
}
std::stringstream written;
written << in.rdbuf();... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x398, %rsp # imm = 0x398
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x190(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x15b00
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x1b0(%rsp,%rax)
jne 0x2adca
leaq 0x8(%rsp), %rdi
callq ... | /approvals[P]ApprovalTests/ApprovalTests/utilities/FileUtils.cpp |
ApprovalTests::FileUtils::writeToFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void FileUtils::writeToFile(const std::string& filePath, const std::string& content)
{
std::ofstream out(filePath.c_str(), std::ios::binary | std::ofstream::out);
if (!out)
{
throw std::runtime_error("Unable to write file: " + filePath);
}
out << content;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x28(%rsp), %r15
pushq $0x14
popq %rdx
movq %r15, %rdi
callq 0x156f0
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x2aef1
leaq 0x28(%rsp), %rdi
movq %... | /approvals[P]ApprovalTests/ApprovalTests/utilities/FileUtils.cpp |
ApprovalTests::StringUtils::beginsWith(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | APPROVAL_TESTS_NO_DISCARD
bool StringUtils::beginsWith(std::string value, std::string beginning)
{
if (value.size() < beginning.size())
{
return false;
}
return std::equal(beginning.begin(), beginning.end(), value.begin());
} | movq %rsi, %rax
movq 0x8(%rsi), %rsi
cmpq %rsi, 0x8(%rdi)
jae 0x2b108
xorl %eax, %eax
retq
movq (%rax), %rax
addq %rax, %rsi
movq (%rdi), %rdx
movq %rax, %rdi
jmp 0x20d48
nop
| /approvals[P]ApprovalTests/ApprovalTests/utilities/StringUtils.cpp |
ApprovalTests::StringUtils::leftTrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | APPROVAL_TESTS_NO_DISCARD
std::string StringUtils::leftTrim(std::string s)
{
s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
return !std::isspace(ch);
}));
return s;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
leaq (%r15,%rbx), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rbp
sarq $0x2, %rbp
movq %r15, %r12
testq %rbp, %rbp
jle 0x2b1db
movq %r12, %rdi
callq 0x2b478
testb %al... | /approvals[P]ApprovalTests/ApprovalTests/utilities/StringUtils.cpp |
ApprovalTests::StringUtils::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | APPROVAL_TESTS_NO_DISCARD
std::string StringUtils::trim(std::string s)
{
s = leftTrim(s);
s = rightTrim(s);
return s;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x15860
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2b15a
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x157c0
movq %r15, %rdi
callq 0x15c18
leaq 0x40(%rsp), %rdi
callq 0x15c18
leaq 0x20(%r... | /approvals[P]ApprovalTests/ApprovalTests/utilities/StringUtils.cpp |
ApprovalTests::CIBuildOnlyReporter::report(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | bool CIBuildOnlyReporter::report(std::string received, std::string approved) const
{
if (!isRunningUnderCI())
{
return false;
}
m_reporter->report(received, approved);
// Return true regardless of whether our report succeeded or not,
// so that no later re... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x2c502
movl %eax, %ebx
testb %al, %al
je 0x2c4d0
movq 0x8(%r14), %r14
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x15860
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x15860
movq (%r14), %rax
leaq 0x28(%rs... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CIBuildOnlyReporter.cpp |
ApprovalTests::ClipboardReporter::getCommandLineFor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string ClipboardReporter::getCommandLineFor(const std::string& received,
const std::string& approved,
bool isWindows)
{
if (isWindows)
{
return std::string("move /Y ") + "\"" + ... | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
je 0x2c622
leaq 0x3c6e2(%rip), %rsi # 0x68c86
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x15250
leaq 0x40954(%rip), %rdx # 0x6cf0e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x17d25
l... | /approvals[P]ApprovalTests/ApprovalTests/reporters/ClipboardReporter.cpp |
ApprovalTests::CommandReporter::assembleFullCommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string CommandReporter::assembleFullCommand(const std::string& received,
const std::string& approved) const
{
auto convertedCommand = '"' + converter->convertProgramForCygwin(cmd) + '"';
auto convertedReceived =
'"' + converter->c... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x50(%rsi), %rsi
leaq 0x8(%r14), %rdx
movq (%rsi), %rax
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq *0x10(%rax)
leaq 0x80(%rsp), %rdi
pushq $0x22
popq %r... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CommandReporter.cpp |
ApprovalTests::CommandReporter::exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool CommandReporter::exists(const std::string& command)
{
bool foundByWhich = false;
if (!SystemUtils::isWindowsOs())
{
std::string which = "which " + command + " > /dev/null 2>&1";
int result = system(which.c_str());
foundByWhich = (result == 0);
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
callq 0x2b550
testb %al, %al
jne 0x2cd86
leaq 0x3bf91(%rip), %rsi # 0x68cd4
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2afc7
leaq 0x3bf81(%rip), %rdx # 0x68cdb
movq %rsp, %rdi
movq %r14, %rsi
callq 0x17d25
leaq 0x20(%rsp), %rdi... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CommandReporter.cpp |
ApprovalTests::CustomReporter::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ApprovalTests::Type) | std::shared_ptr<GenericDiffReporter> CustomReporter::create(std::string path,
Type type)
{
return create(std::move(path), DiffInfo::getDefaultArguments(), type);
} | pushq %rbp
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x15810
leaq 0x8(%rsp), %rdi
callq 0x2d97a
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x2d486
leaq 0x8(%rsp), %rdi
callq 0x15c18
leaq 0x28(%rsp), %rdi
callq 0x15c18
movq %rbx, %rax
ad... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CustomReporter.cpp |
ApprovalTests::CustomReporter::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ApprovalTests::Type) | std::shared_ptr<GenericDiffReporter>
CustomReporter::create(std::string path, std::string arguments, Type type)
{
DiffInfo info(std::move(path), std::move(arguments), type);
return std::make_shared<GenericDiffReporter>(info);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x15810
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x15810
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x2da... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CustomReporter.cpp |
ApprovalTests::CustomReporter::createForegroundReporter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ApprovalTests::Type, bool) | std::shared_ptr<GenericDiffReporter> CustomReporter::createForegroundReporter(
std::string path, Type type, bool allowNonZeroExitCodes)
{
return createForegroundReporter(std::move(path),
DiffInfo::getDefaultArguments(),
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x15810
movq %rsp, %rdi
callq 0x2d97a
movzbl %r14b, %r8d
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
movl %ebp, %ecx
callq 0x2d5b0
movq %rsp, %rdi
callq 0x15c18
leaq 0x20(%rsp), %rdi
... | /approvals[P]ApprovalTests/ApprovalTests/reporters/CustomReporter.cpp |
ApprovalTests::DefaultFrontLoadedReporter::DefaultFrontLoadedReporter() | DefaultFrontLoadedReporter::DefaultFrontLoadedReporter()
: FirstWorkingReporter({new CIBuildOnlyReporter()})
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r12
pushq $0x18
popq %rdi
callq 0x15640
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1db70
leaq 0x38(%rsp), %r15
leaq 0x28(%rsp), %r14
movaps -0x8(%r14), %xmm0
movaps %xmm0, -0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r14)
leaq 0... | /approvals[P]ApprovalTests/ApprovalTests/reporters/DefaultFrontLoadedReporter.cpp |
ApprovalTests::DiffInfo::getProgramFileLocations[abi:cxx11]() | std::vector<std::string> DiffInfo::getProgramFileLocations()
{
std::vector<std::string> possibleWindowsPaths;
const std::vector<const char*> envVars = {
"ProgramFiles", "ProgramW6432", "ProgramFiles(x86)"};
for (const auto& envVar : envVars)
{
std::string env... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x76713(%rip), %rax # 0xa41a8
leaq 0x20(%rsp), %rsi
movq %rax, 0x10(%rsi)
movups 0x766f3(%rip), %xmm0 # 0xa4198
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
push... | /approvals[P]ApprovalTests/ApprovalTests/reporters/DiffInfo.cpp |
ApprovalTests::DiffInfo::getProgramForOs[abi:cxx11]() const | std::string DiffInfo::getProgramForOs() const
{
std::string result = program;
if (result.rfind(programFileTemplate(), 0) == 0)
{
std::vector<std::string> possibleWindowsPaths = getProgramFileLocations();
for (const auto& path : possibleWindowsPaths)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x15860
leaq 0x38(%rsp), %rdi
callq 0x2d958
movq %rsp, %rdi
leaq 0x38(%rsp), %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x154e0
movq %rax, %r15
movq %r14, %rdi
callq 0x15c18
testq %r15, %r15
jne 0x2d... | /approvals[P]ApprovalTests/ApprovalTests/reporters/DiffInfo.cpp |
ApprovalTests::GenericDiffReporter::GenericDiffReporter(ApprovalTests::DiffInfo const&) | GenericDiffReporter::GenericDiffReporter(const DiffInfo& info)
: CommandReporter(info.getProgramForOs(), info.arguments, &launcher)
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x755e8(%rip), %r15 # 0xa41c0
movq %r15, (%rdi)
leaq 0x20(%rsp), %rdi
callq 0x2db52
addq $0x20, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x15860
leaq 0x60(%rbx), %r14
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
movq %... | /approvals[P]ApprovalTests/ApprovalTests/reporters/GenericDiffReporter.cpp |
ApprovalTests::EmptyFileCreatorFactory::defaultCreator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void EmptyFileCreatorFactory::defaultCreator(std::string fullFilePath)
{
StringWriter s("", "");
s.write(fullFilePath);
} | pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x3e09b(%rip), %rsi # 0x6cde1
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x15250
leaq 0x3e085(%rip), %rsi # 0x6cde1
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x15250
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x2b8b4
leaq... | /approvals[P]ApprovalTests/ApprovalTests/utilities/EmptyFileCreatorFactory.cpp |
ApprovalTests::FileUtilsSystemSpecific::getCommandLineForCopy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string FileUtilsSystemSpecific::getCommandLineForCopy(
const std::string& source, const std::string& destination, bool isWindows)
{
if (isWindows)
{
return std::string("copy /Y ") + "\"" + source + "\" \"" + destination + "\"";
}
else
{
re... | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testl %ecx, %ecx
je 0x2eee2
leaq 0x3a71b(%rip), %rsi # 0x6957f
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x15250
leaq 0x3e094(%rip), %rdx # 0x6cf0e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x17d25
l... | /approvals[P]ApprovalTests/ApprovalTests/utilities/FileUtilsSystemSpecific.cpp |
ApprovalTests::ComparatorDisposer::ComparatorDisposer(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<ApprovalTests::ApprovalComparator>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cx... | ComparatorDisposer::ComparatorDisposer(
ComparatorContainer& comparators_,
const std::string& extensionWithDot,
std::shared_ptr<ApprovalTests::ApprovalComparator> previousComparator_,
std::shared_ptr<ApprovalTests::ApprovalComparator> newComparator)
: comparators(comparators_)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
movb $0x1, (%rdi)
movq %rsi, 0x8(%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x15860
leaq 0x38(%r15), %rax
movq %rax, (%rsp)
andq $0x0, 0x38(%... | /approvals[P]ApprovalTests/ApprovalTests/comparators/ComparatorDisposer.cpp |
ApprovalTests::ComparatorDisposer::ComparatorDisposer(ApprovalTests::ComparatorDisposer&&) | ComparatorDisposer::ComparatorDisposer(ComparatorDisposer&& other) noexcept
: comparators(other.comparators)
, ext_(std::move(other.ext_))
, previousComparator(std::move(other.previousComparator))
{
other.isActive = false;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
addq $0x10, %rsi
callq 0x15810
andq $0x0, 0x38(%r14)
movups 0x30(%rbx), %xmm0
andq $0x0, 0x38(%rbx)
movups %xmm0, 0x30(%r14)
andq $0x0, 0x30(%rbx)
movb $0x0, (%rbx)
addq $0x8, %r... | /approvals[P]ApprovalTests/ApprovalTests/comparators/ComparatorDisposer.cpp |
Catch::Benchmark::Detail::analyse(Catch::IConfig const&, std::chrono::duration<double, std::ratio<1l, 1000000000l>>*, std::chrono::duration<double, std::ratio<1l, 1000000000l>>*) | SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) {
if (!cfg.benchmarkNoAnalysis()) {
std::vector<double> samples;
samples.reserve(static_cast<size_t>(last - first));
for (auto current = first; current != last; ++cur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0xc0(%rax)
movq %r14, %rsi
subq %r15, %rsi
sarq $0x3, %rsi
xorpd %xmm0, %xmm0
testb %al, %al
je 0x2feec
leaq 0x50(%rsp), %rdi
movapd... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Benchmark::Detail::analyse_samples(double, unsigned int, double*, double*) | bootstrap_analysis analyse_samples(double confidence_level,
unsigned int n_resamples,
double* first,
double* last) {
auto mean = &Detail::mean;
aut... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x98(%rsp), %r12
movl %esi, (%r12)
movq %rdx, 0x8(%r12)
movq %rcx, 0x10(%r12)
movsd %xmm0, 0x18(%r12)
leaq 0x395(%rip), %rdx # 0x304d7
leaq 0x78(%rsp), %r13
movq %r13, %rdi
movq ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Benchmark::Detail::normal_quantile(double) | double normal_quantile(double p) {
static const double ROOT_TWO = std::sqrt(2.0);
double result = 0.0;
assert(p >= 0 && p <= 1);
if (p < 0 || p > 1) {
return result;
}
result = -erfc_inv(2.0 * p);
... | pushq %rax
movapd %xmm0, %xmm1
movb 0x784a6(%rip), %al # 0xa8d38
testb %al, %al
je 0x308c9
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0x308c7
ucomisd 0x38d68(%rip), %xmm1 # 0x69610
ja 0x308c7
addsd %xmm1, %xmm1
movapd %xmm1, %xmm0
callq 0x30516
xorpd 0x38fd1(%rip), %xmm0 # 0x69890
mulsd 0x78469(%rip), %xmm0 ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Benchmark::Detail::(anonymous namespace)::standard_deviation(double const*, double const*) | static double
standard_deviation( double const* first, double const* last ) {
auto m = Catch::Benchmark::Detail::mean( first, last );
double variance =
std::accumulate( first,
last,
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x304d7
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movq %r14, %rax
cmpq %rbx, %rax
je 0x30c13
movsd (%rax), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
addq $0x8, %rax
jmp 0x30bf8
subq %r14, %rbx
sarq $0x3, %rbx
cvtsi2sd %rbx, %xmm1
d... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Approx::setMargin(double) | void Approx::setMargin(double newMargin) {
CATCH_ENFORCE(newMargin >= 0,
"Invalid Approx::margin: " << newMargin << '.'
<< " Approx::Margin has to be non-negative.");
m_margin = newMargin;
} | pushq %rbx
subq $0x40, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x30fd0
movsd %xmm0, 0x8(%rdi)
addq $0x40, %rsp
popq %rbx
retq
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3c508
movq 0x8(%rbx), %rbx
leaq 0x3a523(%rip), %rsi # 0x6b511
movq %rbx, %rdi
callq 0x15630
movq %rbx, %rdi
movsd... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::AssertionResultData::reconstructExpression[abi:cxx11]() const | std::string AssertionResultData::reconstructExpression() const {
if( reconstructedExpression.empty() ) {
if( lazyExpression ) {
ReusableStringStream rss;
rss << lazyExpression;
reconstructedExpression = rss.str();
}
}
retur... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
cmpq $0x0, 0x28(%rsi)
jne 0x31255
movq %rsi, %r15
cmpq $0x0, 0x40(%rsi)
je 0x31255
addq $0x40, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3c508
movq 0x8(%r12), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3b706
add... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::AssertionResult::getExpressionInMacro[abi:cxx11]() const | std::string AssertionResult::getExpressionInMacro() const {
if ( m_info.macroName.empty() ) {
return static_cast<std::string>( m_info.capturedExpression );
}
std::string expr;
expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
expr += m_in... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x31402
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x28(%r14), %rcx
leaq (%rax,%rcx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x15950
movq (%r14), %rsi
movq 0x8(%r14)... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::operator==(Catch::ProcessedReporterSpec const&, Catch::ProcessedReporterSpec const&) | bool operator==( ProcessedReporterSpec const& lhs,
ProcessedReporterSpec const& rhs ) {
return lhs.name == rhs.name &&
lhs.outputFilename == rhs.outputFilename &&
lhs.colourMode == rhs.colourMode &&
lhs.customOptions == rhs.customOptions;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1735e
testb %al, %al
je 0x3156d
leaq 0x20(%r14), %rdi
leaq 0x20(%rbx), %rsi
callq 0x1735e
testb %al, %al
je 0x3156d
movb 0x40(%r14), %al
cmpb 0x40(%rbx), %al
jne 0x3156d
addq $0x48, %r14
addq $0x48, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TestSpecParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
m_mode = None;
m_exclusion = false;
m_arg = m_tagAliases->expandAliases( arg );
m_escapeChars.clear();
m_substring.reserve(m_arg.size());
m_patternName.reserve(m_arg.size());
m_realPatternPos = 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
andl $0x0, (%rdi)
movq %rsi, %r14
movb $0x0, 0x8(%rdi)
movq 0xf8(%rdi), %rsi
movq (%rsi), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq *0x18(%rax)
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x157c0
movq %r15, %rdi
callq 0x15c18
movq 0x80(%... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Detail::getEnv(char const*) | char const* getEnv( char const* varName ) {
# if defined( _MSC_VER )
# pragma warning( push )
# pragma warning( disable : 4996 ) // use getenv_s instead of getenv
# endif
return std::getenv( varName );
# if defined( _MSC_VER )
# pragma warning( pop )
# endif
} | jmp 0x157b0
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Capturer::Capturer(Catch::StringRef, Catch::SourceLineInfo const&, Catch::ResultWas::OfType, Catch::StringRef) | Capturer::Capturer( StringRef macroName,
SourceLineInfo const& lineInfo,
ResultWas::OfType resultType,
StringRef names ):
m_resultCapture( getResultCapture() ) {
auto trimmed = [&] (size_t start, size_t end) {
while (nam... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdi, %rbx
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movl %r8d, 0x14(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x32584
leaq 0x100(%rsp), %r14
movq %rax, 0x18(%rbx)
movq %rbx, 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Capturer::captureValue(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Capturer::captureValue( size_t index, std::string const& value ) {
assert( index < m_messages.size() );
m_messages[index].message += value;
m_resultCapture.pushScopedMessage( m_messages[index] );
m_captured++;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
imulq $0x48, %rsi, %r14
leaq (%rax,%r14), %rdi
addq $0x10, %rdi
movq %rdx, %rsi
callq 0x15b90
movq 0x18(%rbx), %rdi
addq (%rbx), %r14
movq (%rdi), %rax
movq %r14, %rsi
callq *0x60(%rax)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::cleanupSingletons() | void cleanupSingletons() {
auto& singletons = getSingletons();
for( auto singleton : *singletons )
delete singleton;
delete singletons;
singletons = nullptr;
} | pushq %r14
pushq %rbx
pushq %rax
callq 0x3e961
movq 0x76695(%rip), %rax # 0xa9158
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0x32ae3
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x32add
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rbx
jmp 0x32aca
movq 0x7666e(%rip), %rbx # 0xa9158
testq %rbx, %rbx
je ... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Session::Session() | Session::Session() {
static bool alreadyInstantiated = false;
if( alreadyInstantiated ) {
CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
callq 0x50ee6
leaq 0x60(%rbx), %r14
movq %r14, %rdi
callq 0x50f0e
andq $0x0, 0x170(%rbx)
movb $0x0, 0x178(%rbx)
cmpb $0x1, 0x761b5(%rip) # 0xa8d40
je 0x32d9b
callq 0x4db2c
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::makeStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
if ( filename.empty() || filename == "-" ) {
return Detail::make_unique<Detail::CoutStream>();
}
if( filename[0] == '%' ) {
if ( filename == "%debug" ) {
return Detail::make_un... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x33013
movq %rsi, %r12
leaq 0x3a849(%rip), %rsi # 0x6d850
movq %r12, %rdi
callq 0x20b33
testb %al, %al
je 0x33041
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x3b25c
movq (%r14), %rax
andq $0x0, (%r14)
movq %rax, (... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::makeColourImpl(Catch::ColourMode, Catch::IStream*) | Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
IStream* stream ) {
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
if ( colourSelection == ColourMode::Win32 ) {
return Detail::make_unique<Win32ColourImpl>( stream );
}
#e... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
testl %esi, %esi
je 0x33346
movl %esi, %ebp
cmpl $0x3, %esi
je 0x33392
cmpl $0x1, %ebp
je 0x3336c
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x3c508
movq 0x8(%rbx), %rbx
leaq 0x38fa5(%rip), %rsi # 0x6c2bc
movq %rbx, %rdi
callq 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::TextFlow::operator<<(std::ostream&, Catch::TextFlow::Column const&) | std::ostream& operator<<( std::ostream& os, Column const& col ) {
bool first = true;
for ( auto line : col ) {
if ( first ) {
first = false;
} else {
os << '\n';
}
os << line;
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x40abc
movq (%r14), %r13
addq 0x8(%r14), %r13
movb $0x1, %bpl
leaq 0x8(%rsp), %r12
cmpq %r13, 0x38(%rsp)
jne 0x33434
cmpq %r14, 0x28(%rsp)
je 0x3346f
movq %r12,... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::makeCommandLineParser(Catch::ConfigData&) | Clara::Parser makeCommandLineParser( ConfigData& config ) {
using namespace Clara;
auto const setWarning = [&]( std::string const& warning ) {
if ( warning == "NoAssertions" ) {
config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x19a8, %rsp # imm = 0x19A8
movq %rsi, %r14
movq %rdi, %r15
addq $0xa8, %rsi
leaq 0x70(%rsp), %rdi
callq 0x3985a
leaq 0x7(%r14), %rsi
leaq 0xc30(%rsp), %rdi
callq 0x3a5ee
leaq 0xc88(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xc30(%rsp), %rdx... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Session::showHelp() const | void Session::showHelp() const {
Catch::cout()
<< "\nCatch2 v" << libraryVersion() << '\n'
<< m_cli << '\n'
<< "For more detailed usage please see the project docs\n\n" << std::flush;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x72afe(%rip), %rdi # 0xa7f98
leaq 0x36299(%rip), %rsi # 0x6b73a
callq 0x15630
movq %rax, %r14
callq 0x35584
leaq 0x73893(%rip), %rsi # 0xa8d48
movq %r14, %rdi
callq 0x354fd
pushq $0xa
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x15770
movq %rax, %r... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::operator<<(std::ostream&, Catch::Version const&) | std::ostream& operator << ( std::ostream& os, Version const& version ) {
os << version.majorVersion << '.'
<< version.minorVersion << '.'
<< version.patchNumber;
// branchName is never null -> 0th char is \0 if it is empty
if (version.branchName[0]) {
os << '... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x15440
pushq $0x2e
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0x15770
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x15440
movq %rax, %rdi
movl %ebp, %esi
callq 0x15770
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x15440
movq 0x... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Session::applyCommandLine(int, char const* const*) | int Session::applyCommandLine( int argc, char const * const * argv ) {
if( m_startupExceptions )
return 1;
auto result = m_cli.parse( Clara::Args( argc, argv ) );
if( !result ) {
config();
getCurrentMutableContext().setConfig(m_config.get());
aut... | pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
cmpb $0x0, 0x178(%rdi)
je 0x35721
pushq $0x1
popq %rbx
jmp 0x358ae
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3a588
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3593c
leaq 0x30(%rsp), %rdi
callq 0x55ab8
cmpl $0x0, 0x68(%rsp)
je 0x3586... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Clara::Detail::ParserBase::parse(Catch::Clara::Args const&) const | InternalParseResult ParserBase::parse( Args const& args ) const {
return parse( static_cast<std::string>(args.exeName()), TokenStream( args ) );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movups (%rdx), %xmm0
leaq 0x50(%rsp), %rsi
movups %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x50b9e
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x38bce
movq (%r14), %rax
leaq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbx,... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Session::run() | int Session::run() {
if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush;
static_cast<void>(std::getchar());
}
int exitCode = runInternal();
if( ( m_configData... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testb $0x1, 0xc0(%rdi)
je 0x35a26
movq 0x7258b(%rip), %rdi # 0xa7f98
leaq 0x35df3(%rip), %rsi # 0x6b807
callq 0x15630
movq %rax, %rdi
callq 0x15450
callq 0x15890
movq %r14, %rdi
callq 0x35a7a
movl %eax, %ebx
testb $0x2, 0xc0(%r14)
je 0x35a6f
movq 0x72557(%rip), %... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
Catch::Session::runInternal() | int Session::runInternal() {
if( m_startupExceptions )
return 1;
if (m_configData.showHelp || m_configData.libIdentify) {
return 0;
}
if ( m_configData.shardIndex >= m_configData.shardCount ) {
Catch::cerr() << "The shard count (" << m_configData.sha... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
pushq $0x1
popq %rbp
cmpb $0x0, 0x178(%rdi)
je 0x35a9e
movl %ebp, %ebx
jmp 0x360c7
movq %rdi, %r12
xorl %ebx, %ebx
cmpb $0x0, 0x67(%rdi)
jne 0x360c7
cmpb $0x0, 0x6a(%r12)
jne 0x360c7
movl 0x78(%r12), %eax
cmpl 0... | /approvals[P]ApprovalTests/third_party/catch2v3_amalgamated/catch_amalgamated.cpp |
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.