name
string | code
string | asm
string | file
string |
|---|---|---|---|
destroyContextEGL
|
static void destroyContextEGL(_GLFWwindow* window)
{
#if defined(_GLFW_X11)
// NOTE: Do not unload libGL.so.1 while the X11 display is still open,
// as it will make XCloseDisplay segfault
if (window->context.client != GLFW_OPENGL_API)
#endif // _GLFW_X11
{
if (window->context.egl.client)
{
_glfw_dlclose(window->context.egl.client);
window->context.egl.client = NULL;
}
}
if (window->context.egl.surface)
{
eglDestroySurface(_glfw.egl.display, window->context.egl.surface);
window->context.egl.surface = EGL_NO_SURFACE;
}
if (window->context.egl.handle)
{
eglDestroyContext(_glfw.egl.display, window->context.egl.handle);
window->context.egl.handle = EGL_NO_CONTEXT;
}
}
|
pushq %rbx
movq %rdi, %rbx
cmpl $0x30001, 0x1f8(%rdi) # imm = 0x30001
je 0x2c345
movq 0x298(%rbx), %rdi
testq %rdi, %rdi
je 0x2c345
callq 0x143b0
movq $0x0, 0x298(%rbx)
movq 0x290(%rbx), %rsi
testq %rsi, %rsi
je 0x2c370
leaq 0x66168(%rip), %rax # 0x924c0
movq 0x20f88(%rax), %rdi
callq *0x20ff8(%rax)
movq $0x0, 0x290(%rbx)
movq 0x288(%rbx), %rsi
testq %rsi, %rsi
je 0x2c39b
leaq 0x6613d(%rip), %rax # 0x924c0
movq 0x20f88(%rax), %rdi
callq *0x21000(%rax)
movq $0x0, 0x288(%rbx)
popq %rbx
retq
|
/tuket[P]gltf_viewer/libs/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->accumGreenBits +
fbconfig->accumBlueBits +
fbconfig->accumAlphaBits;
if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"OSMesa: OpenGL ES is not available on OSMesa");
return GLFW_FALSE;
}
if (ctxconfig->share)
share = ctxconfig->share->context.osmesa.handle;
if (OSMesaCreateContextAttribs)
{
int index = 0, attribs[40];
setAttrib(OSMESA_FORMAT, OSMESA_RGBA);
setAttrib(OSMESA_DEPTH_BITS, fbconfig->depthBits);
setAttrib(OSMESA_STENCIL_BITS, fbconfig->stencilBits);
setAttrib(OSMESA_ACCUM_BITS, accumBits);
if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE)
{
setAttrib(OSMESA_PROFILE, OSMESA_CORE_PROFILE);
}
else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE)
{
setAttrib(OSMESA_PROFILE, OSMESA_COMPAT_PROFILE);
}
if (ctxconfig->major != 1 || ctxconfig->minor != 0)
{
setAttrib(OSMESA_CONTEXT_MAJOR_VERSION, ctxconfig->major);
setAttrib(OSMESA_CONTEXT_MINOR_VERSION, ctxconfig->minor);
}
if (ctxconfig->forward)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"OSMesa: Forward-compatible contexts not supported");
return GLFW_FALSE;
}
setAttrib(0, 0);
window->context.osmesa.handle =
OSMesaCreateContextAttribs(attribs, share);
}
else
{
if (ctxconfig->profile)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"OSMesa: OpenGL profiles unavailable");
return GLFW_FALSE;
}
window->context.osmesa.handle =
OSMesaCreateContextExt(OSMESA_RGBA,
fbconfig->depthBits,
fbconfig->stencilBits,
accumBits,
share);
}
if (window->context.osmesa.handle == NULL)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"OSMesa: Failed to create context");
return GLFW_FALSE;
}
window->context.makeCurrent = makeContextCurrentOSMesa;
window->context.swapBuffers = swapBuffersOSMesa;
window->context.swapInterval = swapIntervalOSMesa;
window->context.extensionSupported = extensionSupportedOSMesa;
window->context.getProcAddress = getProcAddressOSMesa;
window->context.destroy = destroyContextOSMesa;
return GLFW_TRUE;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
cmpl $0x30002, (%rsi) # imm = 0x30002
jne 0x2c724
leaq 0x253b5(%rip), %rsi # 0x51acd
xorl %ebp, %ebp
movl $0x10006, %edi # imm = 0x10006
jmp 0x2c8e4
movq %rdi, %rbx
movl 0x1c(%rdx), %ecx
addl 0x18(%rdx), %ecx
addl 0x20(%rdx), %ecx
movq 0x28(%rsi), %rax
testq %rax, %rax
je 0x2c742
movq 0x2a0(%rax), %r8
jmp 0x2c745
xorl %r8d, %r8d
addl 0x24(%rdx), %ecx
leaq 0x65d71(%rip), %r9 # 0x924c0
movq 0x21048(%r9), %rax
testq %rax, %rax
je 0x2c7b2
movabsq $0x190800000022, %rdi # imm = 0x190800000022
movq %rdi, (%rsp)
movl $0x30, 0x8(%rsp)
movl 0x10(%rdx), %edi
movl %edi, 0xc(%rsp)
movl $0x31, 0x10(%rsp)
movl 0x14(%rdx), %edx
movl %edx, 0x14(%rsp)
movl $0x32, 0x18(%rsp)
movl %ecx, 0x1c(%rsp)
movl 0x1c(%rsi), %edx
cmpl $0x32001, %edx # imm = 0x32001
je 0x2c7c8
movl $0x8, %ecx
cmpl $0x32002, %edx # imm = 0x32002
jne 0x2c7de
movl $0x35, %ecx
jmp 0x2c7cd
cmpl $0x0, 0x1c(%rsi)
je 0x2c858
leaq 0x253d3(%rip), %rsi # 0x51b96
jmp 0x2c8dd
movl $0x34, %ecx
movl $0x33, 0x20(%rsp)
movl %ecx, 0x24(%rsp)
movl $0xa, %ecx
movl 0x8(%rsi), %edx
cmpl $0x1, %edx
jne 0x2c7ec
cmpl $0x0, 0xc(%rsi)
je 0x2c814
leal (,%rcx,4), %edi
movl $0x36, (%rsp,%rdi)
movl %ecx, %r9d
movl %edx, 0x4(%rsp,%r9,4)
movl $0x37, 0x8(%rsp,%rdi)
movl 0xc(%rsi), %edx
orl $0x4, %ecx
movl %edx, 0xc(%rsp,%rdi)
movl 0x10(%rsi), %r14d
testl %r14d, %r14d
je 0x2c832
leaq 0x25340(%rip), %rsi # 0x51b64
movl $0x10007, %edi # imm = 0x10007
xorl %eax, %eax
callq 0x1d1a1
jmp 0x2c84b
movl %ecx, %ecx
movq $0x0, (%rsp,%rcx,4)
movq %rsp, %rdi
movq %r8, %rsi
callq *%rax
movq %rax, 0x2a0(%rbx)
xorl %ebp, %ebp
testl %r14d, %r14d
jne 0x2c8eb
jmp 0x2c871
movl 0x10(%rdx), %esi
movl 0x14(%rdx), %edx
movl $0x1908, %edi # imm = 0x1908
callq *0x21040(%r9)
movq %rax, 0x2a0(%rbx)
cmpq $0x0, 0x2a0(%rbx)
je 0x2c8d6
leaq 0x77(%rip), %rax # 0x2c8f9
movq %rax, 0x240(%rbx)
leaq 0x149(%rip), %rax # 0x2c9d9
movq %rax, 0x248(%rbx)
leaq 0x13c(%rip), %rax # 0x2c9da
movq %rax, 0x250(%rbx)
leaq 0x12f(%rip), %rax # 0x2c9db
movq %rax, 0x258(%rbx)
leaq 0x124(%rip), %rax # 0x2c9de
movq %rax, 0x260(%rbx)
leaq 0x123(%rip), %rax # 0x2c9eb
movq %rax, 0x268(%rbx)
movl $0x1, %ebp
jmp 0x2c8eb
leaq 0x252dd(%rip), %rsi # 0x51bba
xorl %ebp, %ebp
movl $0x10007, %edi # imm = 0x10007
xorl %eax, %eax
callq 0x1d1a1
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/tuket[P]gltf_viewer/libs/glfw/src/osmesa_context.c
|
destroyContextOSMesa
|
static void destroyContextOSMesa(_GLFWwindow* window)
{
if (window->context.osmesa.handle)
{
OSMesaDestroyContext(window->context.osmesa.handle);
window->context.osmesa.handle = NULL;
}
if (window->context.osmesa.buffer)
{
free(window->context.osmesa.buffer);
window->context.osmesa.width = 0;
window->context.osmesa.height = 0;
}
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x2a0(%rdi), %rdi
testq %rdi, %rdi
je 0x2ca13
leaq 0x65abe(%rip), %rax # 0x924c0
callq *0x21050(%rax)
movq $0x0, 0x2a0(%rbx)
movq 0x2b0(%rbx), %rdi
testq %rdi, %rdi
je 0x2ca2f
callq 0x14600
movq $0x0, 0x2a8(%rbx)
popq %rbx
retq
|
/tuket[P]gltf_viewer/libs/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_RETURN(GLFW_FALSE);
if (!OSMesaGetColorBuffer(window->context.osmesa.handle,
&mesaWidth, &mesaHeight,
&mesaFormat, &mesaBuffer))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"OSMesa: Failed to retrieve color buffer");
return GLFW_FALSE;
}
if (width)
*width = mesaWidth;
if (height)
*height = mesaHeight;
if (format)
*format = mesaFormat;
if (buffer)
*buffer = mesaBuffer;
return GLFW_TRUE;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2caed
leaq 0x65a74(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x2cabc
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x2a0(%rdi), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq *0x21060(%rax)
testl %eax, %eax
je 0x2cac8
testq %r12, %r12
je 0x2ca8f
movl 0xc(%rsp), %eax
movl %eax, (%r12)
testq %r15, %r15
je 0x2ca9b
movl 0x8(%rsp), %eax
movl %eax, (%r15)
testq %r14, %r14
je 0x2caa7
movl 0x4(%rsp), %eax
movl %eax, (%r14)
movl $0x1, %r14d
testq %rbx, %rbx
je 0x2cade
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
jmp 0x2cade
xorl %r14d, %r14d
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x2cad7
leaq 0x25155(%rip), %rsi # 0x51c24
xorl %r14d, %r14d
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1d1a1
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x49ae(%rip), %rdi # 0x314a2
leaq 0x24fff(%rip), %rsi # 0x51afa
leaq 0x250d9(%rip), %rcx # 0x51bdb
movl $0x12d, %edx # imm = 0x12D
callq 0x14320
|
/tuket[P]gltf_viewer/libs/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.osmesa.handle;
}
|
pushq %rbx
leaq 0x658d1(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x2cc06
cmpl $0x0, 0x1f8(%rdi)
je 0x2cc0f
movq 0x2a0(%rdi), %rbx
jmp 0x2cc1f
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2cc16
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
movq %rbx, %rax
popq %rbx
retq
|
/tuket[P]gltf_viewer/libs/glfw/src/osmesa_context.c
|
openJoystickDevice
|
static GLFWbool openJoystickDevice(const char* path)
{
for (int jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
{
if (!_glfw.joysticks[jid].present)
continue;
if (strcmp(_glfw.joysticks[jid].linjs.path, path) == 0)
return GLFW_FALSE;
}
_GLFWjoystickLinux linjs = {0};
linjs.fd = open(path, O_RDONLY | O_NONBLOCK);
if (linjs.fd == -1)
return GLFW_FALSE;
char evBits[(EV_CNT + 7) / 8] = {0};
char keyBits[(KEY_CNT + 7) / 8] = {0};
char absBits[(ABS_CNT + 7) / 8] = {0};
struct input_id id;
if (ioctl(linjs.fd, EVIOCGBIT(0, sizeof(evBits)), evBits) < 0 ||
ioctl(linjs.fd, EVIOCGBIT(EV_KEY, sizeof(keyBits)), keyBits) < 0 ||
ioctl(linjs.fd, EVIOCGBIT(EV_ABS, sizeof(absBits)), absBits) < 0 ||
ioctl(linjs.fd, EVIOCGID, &id) < 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Linux: Failed to query input device: %s",
strerror(errno));
close(linjs.fd);
return GLFW_FALSE;
}
// Ensure this device supports the events expected of a joystick
if (!isBitSet(EV_KEY, evBits) || !isBitSet(EV_ABS, evBits))
{
close(linjs.fd);
return GLFW_FALSE;
}
char name[256] = "";
if (ioctl(linjs.fd, EVIOCGNAME(sizeof(name)), name) < 0)
strncpy(name, "Unknown", sizeof(name));
char guid[33] = "";
// Generate a joystick GUID that matches the SDL 2.0.5+ one
if (id.vendor && id.product && id.version)
{
sprintf(guid, "%02x%02x0000%02x%02x0000%02x%02x0000%02x%02x0000",
id.bustype & 0xff, id.bustype >> 8,
id.vendor & 0xff, id.vendor >> 8,
id.product & 0xff, id.product >> 8,
id.version & 0xff, id.version >> 8);
}
else
{
sprintf(guid, "%02x%02x0000%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x00",
id.bustype & 0xff, id.bustype >> 8,
name[0], name[1], name[2], name[3],
name[4], name[5], name[6], name[7],
name[8], name[9], name[10]);
}
int axisCount = 0, buttonCount = 0, hatCount = 0;
for (int code = BTN_MISC; code < KEY_CNT; code++)
{
if (!isBitSet(code, keyBits))
continue;
linjs.keyMap[code - BTN_MISC] = buttonCount;
buttonCount++;
}
for (int code = 0; code < ABS_CNT; code++)
{
linjs.absMap[code] = -1;
if (!isBitSet(code, absBits))
continue;
if (code >= ABS_HAT0X && code <= ABS_HAT3Y)
{
linjs.absMap[code] = hatCount;
hatCount++;
// Skip the Y axis
code++;
}
else
{
if (ioctl(linjs.fd, EVIOCGABS(code), &linjs.absInfo[code]) < 0)
continue;
linjs.absMap[code] = axisCount;
axisCount++;
}
}
_GLFWjoystick* js =
_glfwAllocJoystick(name, guid, axisCount, buttonCount, hatCount);
if (!js)
{
close(linjs.fd);
return GLFW_FALSE;
}
strncpy(linjs.path, path, sizeof(linjs.path) - 1);
memcpy(&js->linjs, &linjs, sizeof(linjs));
pollAbsState(js);
_glfwInputJoystick(js, GLFW_CONNECTED);
return GLFW_TRUE;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20e8, %rsp # imm = 0x20E8
movq %rdi, %rbx
movl $0x484, %r14d # imm = 0x484
addq 0x2b22f(%rip), %r14 # 0x57fd8
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpl $0x0, -0x7c(%r14)
je 0x2cdc5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x146b0
testl %eax, %eax
je 0x2cde3
cmpq $0xf, %r15
leaq 0x1(%r15), %rax
setae %r12b
addq $0x1fa0, %r14 # imm = 0x1FA0
movq %rax, %r15
cmpq $0x10, %rax
jne 0x2cdaf
jmp 0x2cdef
xorl %ebp, %ebp
testb $0x1, %r12b
je 0x2d011
leaq 0x1c4(%rsp), %r14
xorl %ebp, %ebp
movl $0x1f24, %edx # imm = 0x1F24
movq %r14, %rdi
xorl %esi, %esi
callq 0x142b0
movq %rbx, %rdi
movl $0x800, %esi # imm = 0x800
xorl %eax, %eax
callq 0x14350
movl %eax, (%r14)
cmpl $-0x1, %eax
je 0x2d011
movl $0x80044520, %r14d # imm = 0x80044520
leaq 0x14(%rsp), %rdx
movl $0x0, (%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movq $0x0, 0x18(%rsp)
xorl %ebp, %ebp
movl $0x80044520, %esi # imm = 0x80044520
movl %eax, %edi
xorl %eax, %eax
callq 0x146d0
testl %eax, %eax
js 0x2cfe3
movl 0x1c4(%rsp), %edi
leaq 0x5c0001(%r14), %rsi
leaq 0x60(%rsp), %rdx
xorl %eax, %eax
callq 0x146d0
testl %eax, %eax
js 0x2cfe3
movl 0x1c4(%rsp), %edi
leaq 0x40003(%r14), %rsi
leaq 0x18(%rsp), %rdx
xorl %eax, %eax
callq 0x146d0
testl %eax, %eax
js 0x2cfe3
movl 0x1c4(%rsp), %edi
leaq 0x3ffe2(%r14), %rsi
leaq 0xc(%rsp), %rdx
xorl %eax, %eax
callq 0x146d0
testl %eax, %eax
js 0x2cfe3
movb 0x14(%rsp), %al
notb %al
testb $0xa, %al
jne 0x2d204
leaq 0xc0(%rsp), %r15
movl $0x100, %edx # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x142b0
movl 0x1c4(%rsp), %edi
addq $0xfbffe6, %r14 # imm = 0xFBFFE6
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x146d0
testl %eax, %eax
jns 0x2cf45
leaq 0x24e26(%rip), %rsi # 0x51d59
leaq 0xc0(%rsp), %rdi
movl $0x100, %edx # imm = 0x100
callq 0x14290
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movb $0x0, 0x50(%rsp)
movzwl 0xe(%rsp), %r9d
testl %r9d, %r9d
setne %dl
movzwl 0x10(%rsp), %eax
movzwl 0x12(%rsp), %ecx
testw %ax, %ax
setne %sil
andb %dl, %sil
testw %cx, %cx
setne %dl
andb %sil, %dl
cmpb $0x1, %dl
jne 0x2d025
movzwl %ax, %r10d
movzwl %cx, %r14d
movzwl 0xc(%rsp), %ecx
movl $0xff, %r11d
movl %ecx, %edx
andl %r11d, %edx
shrl $0x8, %ecx
movl %r9d, %r8d
andl %r11d, %r8d
shrl $0x8, %r9d
movl %r10d, %r15d
andl %r11d, %r15d
shrl $0x8, %r10d
andl %r14d, %r11d
shrl $0x8, %r14d
leaq 0x24d9b(%rip), %rsi # 0x51d61
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
pushq %r14
pushq %r11
pushq %r10
pushq %r15
callq 0x14080
addq $0x20, %rsp
jmp 0x2d0ca
callq 0x14030
movl (%rax), %edi
callq 0x14180
leaq 0x24d3b(%rip), %rsi # 0x51d31
movl $0x10008, %edi # imm = 0x10008
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d1a1
movl 0x1c4(%rsp), %edi
callq 0x14a30
movl %ebp, %eax
addq $0x20e8, %rsp # imm = 0x20E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0xc(%rsp), %ecx
movzbl %cl, %edx
shrl $0x8, %ecx
movsbl 0xc0(%rsp), %r8d
movsbl 0xc1(%rsp), %r9d
movsbl 0xc2(%rsp), %eax
movq %rax, 0x28(%rsp)
movsbl 0xc3(%rsp), %eax
movq %rax, 0x20(%rsp)
movsbl 0xc4(%rsp), %r14d
movsbl 0xc5(%rsp), %r15d
movsbl 0xc6(%rsp), %r12d
movsbl 0xc7(%rsp), %r13d
movsbl 0xc8(%rsp), %ebp
movsbl 0xc9(%rsp), %r10d
movsbl 0xca(%rsp), %r11d
subq $0x8, %rsp
leaq 0x24ced(%rip), %rsi # 0x51d92
leaq 0x38(%rsp), %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %rbp
pushq %r13
pushq %r12
pushq %r15
pushq %r14
pushq 0x60(%rsp)
pushq 0x70(%rsp)
callq 0x14080
addq $0x50, %rsp
xorl %ebp, %ebp
movl $0x100, %eax # imm = 0x100
movl %eax, %ecx
shrl $0x3, %ecx
movzbl 0x60(%rsp,%rcx), %ecx
movl %eax, %edx
andl $0x7, %edx
btl %edx, %ecx
jae 0x2d0ee
movl %ebp, 0xdc8(%rsp,%rax,4)
incl %ebp
incq %rax
cmpq $0x300, %rax # imm = 0x300
jne 0x2d0d1
xorl %r13d, %r13d
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq %r13d, %r12
movl $0xffffffff, 0x19c8(%rsp,%r12,4) # imm = 0xFFFFFFFF
leal 0x7(%r12), %eax
testl %r12d, %r12d
cmovnsl %r13d, %eax
sarl $0x3, %eax
cltq
movzbl 0x18(%rsp,%rax), %eax
movl %r12d, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jae 0x2d184
movl %r13d, %eax
andl $-0x8, %eax
cmpl $0x10, %eax
jne 0x2d14d
movl %r14d, 0x19c8(%rsp,%r12,4)
incl %r14d
incl %r13d
jmp 0x2d184
movl 0x1c4(%rsp), %edi
leal 0x40(%r13), %esi
orl $0x80184500, %esi # imm = 0x80184500
leaq (%r12,%r12,2), %rax
leaq 0x1ac8(%rsp), %rcx
leaq (%rcx,%rax,8), %rdx
xorl %eax, %eax
callq 0x146d0
testl %eax, %eax
js 0x2d184
movl %r15d, 0x19c8(%rsp,%r12,4)
incl %r15d
leal 0x1(%r13), %eax
cmpl $0x3f, %r13d
movl %eax, %r13d
jl 0x2d102
leaq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %r15d, %edx
movl %ebp, %ecx
movl %r14d, %r8d
callq 0x1da24
testq %rax, %rax
je 0x2d204
movq %rax, %r14
leaq 0x1c8(%rsp), %rdi
movl $0xfff, %edx # imm = 0xFFF
movq %rbx, %rsi
callq 0x14290
movq %r14, %rdi
addq $0x78, %rdi
leaq 0x1c4(%rsp), %rsi
movl $0x1f24, %edx # imm = 0x1F24
callq 0x143d0
movq %r14, %rdi
callq 0x2d508
movq %r14, %rdi
movl $0x40001, %esi # imm = 0x40001
callq 0x1d985
movl $0x1, %ebp
jmp 0x2d011
movl 0x1c4(%rsp), %edi
callq 0x14a30
xorl %ebp, %ebp
jmp 0x2d011
|
/tuket[P]gltf_viewer/libs/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 = (struct inotify_event*) (buffer + offset);
offset += sizeof(struct inotify_event) + e->len;
if (regexec(&_glfw.linjs.regex, e->name, 1, &match, 0) != 0)
continue;
char path[PATH_MAX];
snprintf(path, sizeof(path), "/dev/input/%s", e->name);
if (e->mask & (IN_CREATE | IN_ATTRIB))
openJoystickDevice(path);
else if (e->mask & IN_DELETE)
{
for (int jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
{
if (strcmp(_glfw.joysticks[jid].linjs.path, path) == 0)
{
closeJoystick(_glfw.joysticks + jid);
break;
}
}
}
}
}
|
leaq 0x65203(%rip), %rax # 0x924c0
movl 0x20f38(%rax), %edi
testl %edi, %edi
jle 0x2d418
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 0x14710
testq %rax, %rax
jle 0x2d407
movq %rax, %rbx
movl $0x20f40, %eax # imm = 0x20F40
addq 0x2acd2(%rip), %rax # 0x57fd8
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %r13
leaq 0x20(%rsp), %rax
movl $0x484, %ecx # imm = 0x484
addq 0x2acb7(%rip), %rcx # 0x57fd8
movq %rcx, (%rsp)
xorl %r12d, %r12d
movq %rbx, 0x8(%rsp)
leaq (%rsp,%r12), %rbp
addq $0x1030, %rbp # imm = 0x1030
movl -0x4(%rbp), %r15d
movl $0x1, %edx
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rcx
xorl %r8d, %r8d
movq %rax, %r14
callq 0x14630
testl %eax, %eax
movq %r14, %rax
jne 0x2d3f7
movq %r13, %rbx
leaq (%rsp,%r12), %r13
addq $0x1020, %r13 # imm = 0x1020
movl $0x1000, %esi # imm = 0x1000
movq %rax, %rdi
leaq 0x249a4(%rip), %rdx # 0x51d23
movq %rbp, %rcx
movq %rax, %rbp
xorl %eax, %eax
callq 0x14850
movl 0x4(%r13), %eax
testl $0x104, %eax # imm = 0x104
je 0x2d3a1
movq %rbp, %rdi
callq 0x2cd88
jmp 0x2d3ec
btl $0x9, %eax
jae 0x2d3ec
movq (%rsp), %rbp
xorl %r13d, %r13d
movq %rbp, %rdi
movq %r14, %rsi
callq 0x146b0
testl %eax, %eax
je 0x2d3d6
addq $-0x1fa0, %r13 # imm = 0xE060
addq $0x1fa0, %rbp # imm = 0x1FA0
cmpq $-0x1fa00, %r13 # imm = 0xFFFE0600
jne 0x2d3ae
jmp 0x2d3ec
leaq 0x650e3(%rip), %rdi # 0x924c0
subq %r13, %rdi
addq $0x408, %rdi # imm = 0x408
callq 0x2d294
movq %rbx, %r13
movq 0x8(%rsp), %rbx
movq %r14, %rax
addq %r15, %r12
addq $0x10, %r12
cmpq %r12, %rbx
jg 0x2d32d
addq $0x5028, %rsp # imm = 0x5028
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/tuket[P]gltf_viewer/libs/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;
handleAbsEvent(js, code, info->value);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x197c, %r12d # imm = 0x197C
movl $0x187c, %r13d # imm = 0x187C
movl $0x80184540, %ebp # imm = 0x80184540
xorl %r14d, %r14d
cmpl $0x0, (%rbx,%r13)
js 0x2d558
leaq (%rbx,%r12), %r15
movl 0x78(%rbx), %edi
leaq (%r14,%rbp), %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x146d0
testl %eax, %eax
js 0x2d558
movl (%r15), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2d578
incq %r14
addq $0x18, %r12
addq $0x4, %r13
cmpq $0x40, %r14
jne 0x2d52a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/tuket[P]gltf_viewer/libs/glfw/src/linux_joystick.c
|
Catch::AssertionResult::getExpandedExpression[abi:cxx11]() const
|
std::string AssertionResult::getExpandedExpression() const {
return m_resultData.reconstructedExpression;
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x70(%rsi), %rax
movq 0x78(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5c7ae
movq %rbx, %rax
popq %rbx
retq
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::AssertionResult::getMessage[abi:cxx11]() const
|
std::string AssertionResult::getMessage() const {
return m_resultData.message;
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x90(%rsi), %rax
movq 0x98(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5c7ae
movq %rbx, %rax
popq %rbx
retq
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::AssertionResult::getSourceInfo() const
|
SourceLineInfo AssertionResult::getSourceInfo() const {
return m_info.lineInfo;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x20(%rsi), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x5c7ae
movq 0x40(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::AssertionResult::getTestMacroName[abi:cxx11]() const
|
std::string AssertionResult::getTestMacroName() const {
return m_info.macroName;
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5c7ae
movq %rbx, %rax
popq %rbx
retq
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::startsWith(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 startsWith( std::string const& s, std::string const& prefix ) {
return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rcx
cmpq %rcx, 0x8(%rdi)
jae 0x744f3
xorl %ebp, %ebp
jmp 0x74546
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x576f0
movq 0x8(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0x74529
movq (%rsp), %rbx
testq %rdx, %rdx
je 0x74531
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x576e0
testl %eax, %eax
sete %bpl
jmp 0x74534
movq (%rsp), %rbx
xorl %ebp, %ebp
jmp 0x74534
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
cmpq %rax, %rbx
je 0x74546
movq %rbx, %rdi
callq 0x57630
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::ResultBuilder::captureExpectedException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) {
if( expectedMessage.empty() )
captureExpectedException( Matchers::Impl::Generic::AllOf<std::string>() );
else
captureExpectedException( Matchers::Equals( expectedMessage ) );
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x77051
movq %rsi, %rdx
xorl %eax, %eax
leaq 0x18(%rsp), %rsi
movl %eax, -0x8(%rsi)
leaq 0x4500d(%rip), %r14 # 0xbc028
movq %r14, -0x10(%rsi)
movl %eax, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x8454e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x770d0
leaq 0x30(%rsp), %rax
movq %r14, -0x28(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x77092
callq 0x57630
jmp 0x77092
leaq 0x18(%rsp), %r14
movl $0x0, -0x8(%r14)
leaq 0x4656b(%rip), %r15 # 0xbd5d0
movq %r15, -0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x770d0
movq %r15, 0x8(%rsp)
movq %r14, %rdi
callq 0x841ac
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, 0x8(%rsp)
movq %r14, %rdi
callq 0x841ac
jmp 0x770c8
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq %r14, -0x28(%rax)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x770c8
callq 0x57630
movq %rbx, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TagAliasRegistry::expandAliases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
|
std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
std::string expandedTestSpec = unexpandedTestSpec;
for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
it != itEnd;
++it ) {
std::size_t pos = expandedTestSpec.find( it->first );
if( pos != std::string::npos ) {
expandedTestSpec = expandedTestSpec.substr( 0, pos ) +
it->second.tag +
expandedTestSpec.substr( pos + it->first.size() );
}
}
return expandedTestSpec;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
movq %rax, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x5c7ae
movq 0x20(%r14), %r15
addq $0x10, %r14
cmpq %r14, %r15
je 0x77f02
leaq 0x10(%rsp), %r13
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57ba0
cmpq $-0x1, %rax
je 0x77eee
movq %rax, %rbp
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x576f0
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
movq %r12, %rdi
callq 0x571f0
movq %r13, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x77dbb
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x77dc3
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
addq 0x28(%r15), %rbp
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x576f0
movq (%rsp), %rcx
movl $0xf, %edi
cmpq %r13, %rcx
leaq 0x30(%rsp), %r12
je 0x77e0e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r8
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq (%rdx,%r8), %rax
cmpq %rdi, %rax
jbe 0x77e3f
movl $0xf, %edi
leaq 0x50(%rsp), %r9
cmpq %r9, %rsi
je 0x77e3a
movq 0x50(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x77e49
movq %rsp, %rdi
callq 0x571f0
jmp 0x77e57
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x57740
movq %r12, 0x20(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x77e77
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x77e7f
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x28(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
callq 0x577f0
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x77eb8
callq 0x57630
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x77ecc
callq 0x57630
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x77eda
callq 0x57630
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x77eee
callq 0x57630
movq %r15, %rdi
callq 0x57760
movq %rax, %r15
cmpq %r14, %rax
jne 0x77d56
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x77f3d
callq 0x57630
jmp 0x77f3d
movq %rax, %r14
jmp 0x77f5f
movq %rax, %r14
jmp 0x77f4b
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x77f4b
callq 0x57630
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x77f5f
callq 0x57630
movq (%rbx), %rdi
cmpq 0x60(%rsp), %rdi
je 0x77f6e
callq 0x57630
movq %r14, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestRunStats::~TestRunStats()
|
TestRunStats::~TestRunStats() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x43299(%rip), %rax # 0xbbc40
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x789bc
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::CumulativeReporterBase::SectionNode::~SectionNode()
|
CumulativeReporterBase::SectionNode::~SectionNode() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x4328f(%rip), %rax # 0xbbc60
movq %rax, (%rdi)
movq 0xf8(%rdi), %rdi
leaq 0x108(%rbx), %rax
cmpq %rax, %rdi
je 0x789ec
callq 0x57630
movq 0xd8(%rbx), %rdi
leaq 0xe8(%rbx), %rax
cmpq %rax, %rdi
je 0x78a04
callq 0x57630
leaq 0xc0(%rbx), %rdi
callq 0x7adfe
leaq 0xa8(%rbx), %rdi
callq 0x7ae42
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x7880a
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::CumulativeReporterBase::~CumulativeReporterBase()
|
CumulativeReporterBase::~CumulativeReporterBase() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x43249(%rip), %rax # 0xbbc90
movq %rax, (%rdi)
addq $0xa8, %rdi
callq 0x7ae42
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x78a68
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x78a7a
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x80(%rbx), %rdi
callq 0x7ae6a
leaq 0x68(%rbx), %rdi
callq 0x7ae92
leaq 0x50(%rbx), %rdi
callq 0x7aeba
leaq 0x38(%rbx), %rdi
callq 0x7aee2
leaq 0x20(%rbx), %rdi
callq 0x7adfe
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x78ab9
movq (%rdi), %rax
callq *0x18(%rax)
popq %rbx
retq
jmp 0x78abf
jmp 0x78abf
movq %rax, %rdi
callq 0x5bcbe
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::StreamingReporterBase::~StreamingReporterBase()
|
StreamingReporterBase::~StreamingReporterBase() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x43263(%rip), %rax # 0xbbd38
movq %rax, (%rdi)
addq $0x1b0, %rdi # imm = 0x1B0
callq 0x7af22
leaq 0x90(%rbx), %rdi
callq 0x84b5c
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x78b0a
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x78b0a
callq 0x57630
movq $0x0, 0x50(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x78b2c
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x78b2c
callq 0x57630
movq $0x0, 0x20(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x78b43
movq (%rdi), %rax
callq *0x18(%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x5bcbe
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::WildcardPattern::~WildcardPattern()
|
WildcardPattern::~WildcardPattern() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x43297(%rip), %rax # 0xbbf58
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x78cd6
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestSpec::NamePattern::~NamePattern()
|
TestSpec::NamePattern::~NamePattern() {}
|
movq %rdi, %rax
leaq 0x43292(%rip), %rcx # 0xbbf80
movq %rcx, (%rdi)
leaq 0x43260(%rip), %rcx # 0xbbf58
movq %rcx, 0x10(%rdi)
movq 0x20(%rdi), %rdi
addq $0x30, %rax
cmpq %rax, %rdi
jne 0x57630
retq
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestSpec::TagPattern::~TagPattern()
|
TestSpec::TagPattern::~TagPattern() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x4324b(%rip), %rax # 0xbbfb8
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x78d82
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::Matchers::Impl::StdString::Equals::~Equals()
|
Matchers::Impl::StdString::Equals::~Equals() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x4321f(%rip), %rax # 0xbc028
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x78e1e
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::Matchers::Impl::StdString::Contains::~Contains()
|
Matchers::Impl::StdString::Contains::~Contains() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x4321d(%rip), %rax # 0xbc070
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x78e68
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::Matchers::Impl::StdString::StartsWith::~StartsWith()
|
Matchers::Impl::StdString::StartsWith::~StartsWith() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x4321b(%rip), %rax # 0xbc0b8
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x78eb2
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::Matchers::Impl::StdString::EndsWith::~EndsWith()
|
Matchers::Impl::StdString::EndsWith::~EndsWith() {}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x43219(%rip), %rax # 0xbc100
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x78efc
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::(anonymous namespace)::PosixColourImpl::~PosixColourImpl()
|
virtual void use( Colour::Code _colourCode ) {
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32m" );
case Colour::Blue: return setColour( "[0:34m" );
case Colour::Cyan: return setColour( "[0;36m" );
case Colour::Yellow: return setColour( "[0;33m" );
case Colour::Grey: return setColour( "[1;30m" );
case Colour::LightGrey: return setColour( "[0;37m" );
case Colour::BrightRed: return setColour( "[1;31m" );
case Colour::BrightGreen: return setColour( "[1;32m" );
case Colour::BrightWhite: return setColour( "[1;37m" );
case Colour::Bright: throw std::logic_error( "not a colour" );
}
}
|
jmp 0x57630
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::(anonymous namespace)::PosixColourImpl::setColour(char const*)
|
void setColour( const char* _escapeCode ) {
Catch::cout() << '\033' << _escapeCode;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rsi
movb $0x1b, (%rsi)
movq 0x44d10(%rip), %rdi # 0xbdf90
movl $0x1, %edx
callq 0x57750
movq %rax, %r14
testq %rbx, %rbx
je 0x792aa
movq %rbx, %rdi
callq 0x572f0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x57750
jmp 0x792c4
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x57b50
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::Ptr<Catch::IStreamingReporter>::operator=(Catch::Ptr<Catch::IStreamingReporter> const&)
|
Ptr& operator = ( Ptr const& other ){
Ptr temp( other );
swap( temp );
return *this;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x792f2
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x79303
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5bcbe
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::RunContext::RunContext(Catch::Ptr<Catch::IConfig const> const&, Catch::Ptr<Catch::IStreamingReporter> const&)
|
explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
: m_runInfo( _config->name() ),
m_context( getCurrentMutableContext() ),
m_activeTestCase( CATCH_NULL ),
m_config( _config ),
m_reporter( reporter )
{
m_context.setRunner( this );
m_context.setConfig( m_config );
m_context.setResultCapture( this );
m_reporter->testRunStarting( m_runInfo );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x43f84(%rip), %rax # 0xbd360
movq %rax, (%rdi)
leaq 0x43fea(%rip), %rax # 0xbd3d0
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *0x30(%rax)
leaq 0x10(%rbx), %r14
leaq 0x20(%rbx), %r13
movq %r13, 0x10(%rbx)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5c7ae
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7942c
callq 0x57630
movq %r13, 0x10(%rsp)
callq 0x73ce7
movq %rax, 0x30(%rbx)
xorl %eax, %eax
movq %rax, 0x38(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x50(%rbx)
movq %rax, 0x58(%rbx)
movb %al, 0x60(%rbx)
leaq 0x80(%rbx), %rcx
movq %rcx, 0x70(%rbx)
movq %rax, 0x78(%rbx)
movb %al, 0x80(%rbx)
movq %rax, 0x90(%rbx)
leaq 0xa8(%rbx), %rcx
movq %rcx, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movb %al, 0xa8(%rbx)
leaq 0xd0(%rbx), %rcx
movq %rcx, 0xc0(%rbx)
movq %rax, 0xc8(%rbx)
movb %al, 0xd0(%rbx)
leaq 0xf0(%rbx), %rcx
movq %rcx, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
movb %al, 0xf0(%rbx)
movl $0xffffffff, 0x100(%rbx) # imm = 0xFFFFFFFF
movq (%r15), %rdi
movq %rdi, 0x108(%rbx)
testq %rdi, %rdi
je 0x794db
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x108(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%rbx)
movups %xmm0, 0x120(%rbx)
movups %xmm0, 0x110(%rbx)
movq (%r12), %rdi
movq %rdi, 0x140(%rbx)
testq %rdi, %rdi
je 0x79513
movq (%rdi), %rax
callq *0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x8(%rbx), %rsi
leaq 0x148(%rbx), %r13
movups %xmm0, 0x148(%rbx)
xorl %eax, %eax
movq %rax, 0x158(%rbx)
leaq 0x160(%rbx), %rbp
leaq 0x170(%rbx), %rcx
movq %rcx, 0x160(%rbx)
movq %rax, 0x168(%rbx)
movb %al, 0x170(%rbx)
leaq 0x190(%rbx), %rcx
movq %rcx, 0x180(%rbx)
movq %rax, 0x188(%rbx)
movb %al, 0x190(%rbx)
movq %rax, 0x1a0(%rbx)
leaq 0x1b8(%rbx), %rcx
movq %rcx, 0x1a8(%rbx)
movq %rax, 0x1b0(%rbx)
movb %al, 0x1b8(%rbx)
leaq 0x1d0(%rbx), %r12
movups %xmm0, 0x1d0(%rbx)
movups %xmm0, 0x1e0(%rbx)
movups %xmm0, 0x1f0(%rbx)
movups %xmm0, 0x200(%rbx)
movl $0x0, 0x210(%rbx)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x48(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq 0x140(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x30(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
jmp 0x79690
movq %rax, 0x8(%rsp)
jmp 0x7969e
movq %rax, 0x8(%rsp)
jmp 0x796aa
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x796b4
jmp 0x796b9
movq %rax, 0x8(%rsp)
jmp 0x796b9
movq %rax, 0x8(%rsp)
movq 0x200(%rbx), %rdi
testq %rdi, %rdi
je 0x79655
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x1e8(%rbx), %rdi
testq %rdi, %rdi
je 0x79666
callq 0x57630
movq %r12, %rdi
callq 0x7ef08
movq %rbp, %rdi
callq 0x7a206
movq %r13, %rdi
callq 0x7add6
movq 0x140(%rbx), %rdi
testq %rdi, %rdi
je 0x79690
movq (%rdi), %rax
callq *0x18(%rax)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x7969e
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x74126
movq (%r14), %rdi
cmpq 0x10(%rsp), %rdi
je 0x796b9
callq 0x57630
movq 0x8(%rsp), %rdi
callq 0x57bd0
jmp 0x796c7
jmp 0x796c7
movq %rax, %rdi
callq 0x5bcbe
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::RunContext::testGroupStarting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long)
|
void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x140(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x5c7ae
movq %r14, 0x20(%r12)
movq %rbx, 0x28(%r12)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x38(%rax)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x7972f
callq 0x57630
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x7974e
callq 0x57630
movq %rbx, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestSpecParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
TestSpecParser& parse( std::string const& arg ) {
m_mode = None;
m_exclusion = false;
m_start = std::string::npos;
m_arg = m_tagAliases->expandAliases( arg );
for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
visitChar( m_arg[m_pos] );
if( m_mode == Name )
addPattern<TestSpec::NamePattern>();
return *this;
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x0, (%rdi)
movb $0x0, 0x4(%rdi)
movq $-0x1, 0x8(%rdi)
movq 0x68(%rdi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x18(%rax)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x577f0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x797a5
callq 0x57630
movq $0x0, 0x10(%rbx)
cmpq $0x0, 0x20(%rbx)
je 0x797d7
xorl %eax, %eax
movq 0x18(%rbx), %rcx
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x811f0
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq 0x20(%rbx), %rax
jb 0x797b6
cmpl $0x1, (%rbx)
jne 0x797e4
movq %rbx, %rdi
callq 0x81336
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::RunContext::runTest(Catch::TestCase const&)
|
Totals runTest( TestCase const& testCase ) {
Totals prevTotals = m_totals;
std::string redirectedCout;
std::string redirectedCerr;
TestCaseInfo testInfo = testCase.getTestCaseInfo();
m_reporter->testCaseStarting( testInfo );
m_activeTestCase = &testCase;
do {
m_trackerContext.startRun();
do {
m_trackerContext.startCycle();
m_testCaseTracker = &SectionTracker::acquire( m_trackerContext, testInfo.name );
runCurrentTest( redirectedCout, redirectedCerr );
}
while( !m_testCaseTracker->isSuccessfullyCompleted() && !aborting() );
}
// !TBD: deprecated - this will be replaced by indexed trackers
while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
Totals deltaTotals = m_totals.delta( prevTotals );
if( testInfo.expectedToFail() && deltaTotals.testCases.passed > 0 ) {
deltaTotals.assertions.failed++;
deltaTotals.testCases.passed--;
deltaTotals.testCases.failed++;
}
m_totals.testCases += deltaTotals.testCases;
m_reporter->testCaseEnded( TestCaseStats( testInfo,
deltaTotals,
redirectedCout,
redirectedCerr,
aborting() ) );
m_activeTestCase = CATCH_NULL;
m_testCaseTracker = CATCH_NULL;
return deltaTotals;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x110(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0x118(%rsi), %rax
movq %rax, 0x20(%rsp)
movq 0x120(%rsi), %rax
movq %rax, 0x18(%rsp)
movdqu 0x128(%rsi), %xmm0
movdqa %xmm0, 0x70(%rsp)
movq 0x138(%rsi), %rax
movq %rax, 0x28(%rsp)
leaq 0x60(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x40(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x88(%rsp), %rdi
movq %rdx, %rsi
callq 0x74778
movq 0x140(%r14), %rdi
movq (%rdi), %rax
leaq 0x88(%rsp), %rsi
callq *0x40(%rax)
leaq 0x38(%r14), %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x38(%r14)
leaq 0x200(%r14), %r15
leaq 0x88(%rsp), %r12
leaq 0x50(%rsp), %r13
leaq 0x30(%rsp), %rbp
movq %r15, %rdi
callq 0x81e00
movq 0x200(%r14), %rax
movq %rax, 0x208(%r14)
movl $0x1, 0x210(%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x80402
movq %rax, 0x40(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x81ef6
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
jne 0x7995a
movq (%r14), %rax
movq %r14, %rdi
callq *0x58(%rax)
testb %al, %al
je 0x79909
callq 0x73ce7
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
testb %al, %al
je 0x79979
movq (%r14), %rax
movq %r14, %rdi
callq *0x58(%rax)
testb %al, %al
je 0x79901
movq 0x110(%r14), %rax
subq 0x10(%rsp), %rax
movq 0x118(%r14), %rcx
movq 0x120(%r14), %rdx
xorl %esi, %esi
subq 0x18(%rsp), %rdx
setne %sil
shll $0x4, %esi
addq $0x18, %rsi
subq 0x20(%rsp), %rcx
movq %rax, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq 0x138(%r14), %rax
movl $0x20, %edx
cmoveq %rsi, %rdx
movq %rax, %rsi
subq 0x28(%rsp), %rsi
movdqu 0x128(%r14), %xmm0
movdqa %xmm0, %xmm1
psubq 0x70(%rsp), %xmm1
movdqu %xmm1, 0x18(%rbx)
movq %rsi, 0x28(%rbx)
incq (%rbx,%rdx)
movb 0x190(%rsp), %dil
shrb $0x2, %dil
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
testq %rsi, %rsi
setne %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0x79a26
incq %rcx
movq %rcx, 0x8(%rbx)
decq %rsi
movq %rsi, 0x18(%rbx)
incq %rdx
movq %rdx, 0x20(%rbx)
movq %xmm0, %rcx
addq %rsi, %rcx
movq %rcx, 0x128(%r14)
pshufd $0xee, %xmm0, %xmm0 # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rcx
addq %rdx, %rcx
movq %rcx, 0x130(%r14)
addq 0x28(%rbx), %rax
movq %rax, 0x138(%r14)
movq 0x140(%r14), %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x58(%rax)
movzbl %al, %r9d
leaq 0x198(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x50(%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rbx, %rdx
callq 0x80e28
movq (%r15), %rax
leaq 0x198(%rsp), %rsi
movq %r15, %rdi
callq *0x68(%rax)
leaq 0x198(%rsp), %rdi
callq 0x78864
pxor %xmm0, %xmm0
movq 0x8(%rsp), %rax
movdqu %xmm0, (%rax)
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
leaq 0x40(%rsp), %r15
je 0x79ad0
callq 0x57630
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x79ae6
callq 0x57630
leaq 0x118(%rsp), %rdi
callq 0x828b2
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
callq 0x828b2
movq -0x20(%r14), %rdi
leaq 0xd8(%rsp), %rax
cmpq %rax, %rdi
je 0x79b19
callq 0x57630
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
leaq 0x60(%rsp), %r14
je 0x79b34
callq 0x57630
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x79b4a
callq 0x57630
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x79b59
callq 0x57630
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x79b68
callq 0x57630
movq %rbx, %rax
addq $0x328, %rsp # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x198(%rsp), %rdi
callq 0x78864
jmp 0x79b9d
jmp 0x79b9a
movq %rax, %rbx
jmp 0x79baa
jmp 0x79b9a
jmp 0x79b9a
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x7a514
leaq 0x60(%rsp), %r14
leaq 0x40(%rsp), %rax
movq 0x30(%rsp), %rdi
cmpq %rax, %rdi
je 0x79bc3
callq 0x57630
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x79bd2
callq 0x57630
movq %rbx, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::RunContext::~RunContext()
|
virtual ~RunContext() {
m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x4363e(%rip), %rax # 0xbd360
movq %rax, (%rdi)
leaq 0x436a4(%rip), %rax # 0xbd3d0
movq %rax, 0x8(%rdi)
movq 0x140(%rdi), %r14
movq 0x108(%rdi), %rdi
movq 0x118(%rbx), %r13
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, %ebp
leaq 0x41eec(%rip), %r15 # 0xbbc40
leaq 0x10(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq %rsi, %rdx
callq 0x5c7ae
movslq %ebp, %rax
cmpq %rax, %r13
movups 0x110(%rbx), %xmm0
movups 0x120(%rbx), %xmm1
movups 0x130(%rbx), %xmm2
leaq 0x8(%rsp), %rsi
movups %xmm2, 0x48(%rsi)
movups %xmm1, 0x38(%rsi)
movups %xmm0, 0x28(%rsi)
sete 0x58(%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x78(%rax)
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x79dc4
callq 0x57630
movq 0x200(%rbx), %rdi
testq %rdi, %rdi
je 0x79dd6
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x1e8(%rbx), %rdi
testq %rdi, %rdi
je 0x79de7
callq 0x57630
leaq 0x1d0(%rbx), %rdi
callq 0x7ef08
movq 0x1a8(%rbx), %rdi
leaq 0x1b8(%rbx), %rax
cmpq %rax, %rdi
je 0x79e0b
callq 0x57630
movq 0x180(%rbx), %rdi
leaq 0x190(%rbx), %rax
cmpq %rax, %rdi
je 0x79e23
callq 0x57630
movq 0x160(%rbx), %rdi
leaq 0x170(%rbx), %rax
cmpq %rax, %rdi
je 0x79e3b
callq 0x57630
leaq 0x148(%rbx), %rdi
callq 0x7add6
movq 0x140(%rbx), %rdi
testq %rdi, %rdi
je 0x79e59
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x79e6b
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x50(%rbx), %rdi
callq 0x74126
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x79e86
callq 0x57630
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x79e9b
jmp 0x79e9b
jmp 0x79e9b
movq %rax, %rdi
callq 0x5bcbe
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestSpec::matches(Catch::TestCaseInfo const&) const
|
Generic::AllOf<ExpressionT> Matcher<ExpressionT>::operator && ( Matcher<ExpressionT> const& other ) const {
Generic::AllOf<ExpressionT> allOfExpr;
allOfExpr.add( *this );
allOfExpr.add( other );
return allOfExpr;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x79efa
movq %rsi, %rbx
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
sete %bpl
je 0x79ef5
movq (%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x79eea
addq $0x8, %r12
cmpq %r13, %r12
jne 0x79ece
jmp 0x79ef5
addq $0x18, %r14
cmpq %r15, %r14
jne 0x79ebe
jmp 0x79efc
movb $0x1, %bpl
jmp 0x79efc
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::Matchers::Impl::StdString::EndsWith::toString[abi:cxx11]() const
|
virtual std::string toString() const {
return "ends with: \"" + m_data.m_str + "\"" + m_data.toStringSuffix();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdx
leaq 0x20937(%rip), %rsi # 0x9c313
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x5ed11
leaq 0x1fbbc(%rip), %rsi # 0x9b5ac
movq %r15, %rdi
callq 0x57cc0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x7ba1e
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x7ba25
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl 0x10(%r14), %eax
cmpl $0x1, %eax
leaq 0x20899(%rip), %rcx # 0x9c2e4
leaq 0x20cd4(%rip), %rsi # 0x9c726
cmoveq %rcx, %rsi
leaq 0x13(%rsi), %rdx
cmpl $0x1, %eax
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
cmovneq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x5c0d2
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
movq 0x28(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r15, %rcx
je 0x7ba95
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x7bab3
movl $0xf, %edi
cmpq %r14, %rsi
je 0x7baae
movq 0x30(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x7babd
movq %rsp, %rdi
callq 0x571f0
jmp 0x7bacb
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x57740
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x7baea
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x7baf0
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x7bb1b
callq 0x57630
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7bb29
callq 0x57630
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7bb3c
callq 0x57630
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x7bb60
callq 0x57630
jmp 0x7bb60
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7bb73
callq 0x57630
jmp 0x7bb73
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7bb86
callq 0x57630
movq %rbx, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::WildcardPattern::matches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
|
virtual bool matches( std::string const& str ) const {
switch( m_wildcard ) {
case NoWildcard:
return m_pattern == adjustCase( str );
case WildcardAtStart:
return endsWith( adjustCase( str ), m_pattern );
case WildcardAtEnd:
return startsWith( adjustCase( str ), m_pattern );
case WildcardAtBothEnds:
return contains( adjustCase( str ), m_pattern );
}
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#endif
throw std::logic_error( "Unknown enum" );
#ifdef __clang__
#pragma clang diagnostic pop
#endif
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0xc(%rdi), %eax
cmpq $0x3, %rax
ja 0x7bca6
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x1f0f1(%rip), %rcx # 0x9aca0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x81d8a
movq 0x18(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0x7bc7f
movq 0x8(%rsp), %r14
testq %rdx, %rdx
je 0x7bc88
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x576e0
testl %eax, %eax
sete %bl
jmp 0x7bc8a
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x81d8a
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x744da
jmp 0x7bc6d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x81d8a
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x57ba0
cmpq $-0x1, %rax
setne %bl
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
jmp 0x7bc78
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x81d8a
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x755a7
movl %eax, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x7bc97
jmp 0x7bc9c
movq 0x8(%rsp), %r14
xorl %ebx, %ebx
jmp 0x7bc8a
movb $0x1, %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x7bc9c
movq %r14, %rdi
callq 0x57630
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x57330
movq %rax, %r14
leaq 0x20666(%rip), %rsi # 0x9c320
movq %rax, %rdi
callq 0x57990
movq 0x422e7(%rip), %rsi # 0xbdfb0
movq 0x422b0(%rip), %rdx # 0xbdf80
movq %r14, %rdi
callq 0x57b80
movq %rax, %rbx
movq %r14, %rdi
callq 0x574e0
jmp 0x7bcfd
jmp 0x7bce7
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7bcfd
callq 0x57630
movq %rbx, %rdi
callq 0x57bd0
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestCaseTracking::TrackerBase::close()
|
virtual void close() CATCH_OVERRIDE {
// Close any still open children (e.g. generators)
while( &m_ctx.currentTracker() != this )
m_ctx.currentTracker().close();
switch( m_runState ) {
case NotStarted:
case CompletedSuccessfully:
case Failed:
throw std::logic_error( "Illogical state" );
case NeedsAnotherRun:
break;;
case Executing:
m_runState = CompletedSuccessfully;
break;
case ExecutingChildren:
if( m_children.empty() || m_children.back()->isComplete() )
m_runState = CompletedSuccessfully;
break;
default:
throw std::logic_error( "Unexpected state" );
}
moveToParent();
m_ctx.completeCycle();
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rdi
cmpq %rbx, %rdi
je 0x7bf6a
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x30(%rbx), %rax
jmp 0x7bf55
movl 0x58(%rbx), %eax
cmpq $0x5, %rax
ja 0x7c003
leaq 0x1ed32(%rip), %rcx # 0x9acb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x48(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x7bf9f
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x7bfa6
movl $0x4, 0x58(%rbx)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x7bfe4
movq 0x30(%rbx), %rcx
movq %rax, 0x8(%rcx)
movl $0x2, 0x10(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x57330
movq %rax, %rbx
leaq 0x2039d(%rip), %rsi # 0x9c377
movq %rax, %rdi
callq 0x57990
jmp 0x7c01f
leaq 0x20342(%rip), %rdi # 0x9c32d
leaq 0x1f69f(%rip), %rsi # 0x9b691
leaq 0x2039f(%rip), %rcx # 0x9c398
movl $0x1643, %edx # imm = 0x1643
callq 0x57440
movl $0x10, %edi
callq 0x57330
movq %rax, %rbx
leaq 0x20370(%rip), %rsi # 0x9c387
movq %rax, %rdi
callq 0x57990
movq 0x41f8a(%rip), %rsi # 0xbdfb0
movq 0x41f53(%rip), %rdx # 0xbdf80
movq %rbx, %rdi
callq 0x57b80
jmp 0x7c037
movq %rax, %r14
movq %rbx, %rdi
callq 0x574e0
movq %r14, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestCaseTracking::TrackerBase::fail()
|
virtual void fail() CATCH_OVERRIDE {
m_runState = Failed;
if( m_parent )
m_parent->markAsNeedingAnotherRun();
moveToParent();
m_ctx.completeCycle();
}
|
pushq %rbx
movq %rdi, %rbx
movl $0x5, 0x58(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x7c07e
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x7c07e
movq 0x30(%rbx), %rcx
movq %rax, 0x8(%rcx)
movl $0x2, 0x10(%rcx)
popq %rbx
retq
leaq 0x202a8(%rip), %rdi # 0x9c32d
leaq 0x1f605(%rip), %rsi # 0x9b691
leaq 0x20305(%rip), %rcx # 0x9c398
movl $0x1643, %edx # imm = 0x1643
callq 0x57440
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestCaseTracking::TrackerBase::findChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
virtual ITracker* findChild( std::string const& name ) CATCH_OVERRIDE {
Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( name ) );
return( it != m_children.end() )
? it->get()
: CATCH_NULL;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x5c7ae
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8d83e
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x7c108
callq 0x57630
cmpq 0x48(%rbx), %r14
je 0x7c113
movq (%r14), %rax
jmp 0x7c115
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x7c134
callq 0x57630
movq %rbx, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::XmlReporter::sectionEnded(Catch::SectionStats const&)
|
virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
StreamingReporterBase::sectionEnded( sectionStats );
if( --m_sectionDepth > 0 ) {
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
e.writeAttribute( "successes", sectionStats.assertions.passed );
e.writeAttribute( "failures", sectionStats.assertions.failed );
e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
if ( m_config->showDurations() == ShowDurations::Always )
e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
m_xml.endElement();
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x1b0, %rdi # imm = 0x1B0
movq 0x1b8(%r15), %rsi
addq $-0x68, %rsi
movq %rsi, 0x1b8(%r15)
callq 0x8e912
movl 0x220(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x220(%r15)
cmpl $0x2, %eax
jl 0x7df48
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1e7ba(%rip), %rsi # 0x9c5b2
leaq 0x1e7c1(%rip), %rdx # 0x9c5c0
leaq 0x8(%rsp), %rdi
callq 0x5c0d2
leaq 0x1d8(%r15), %r14
movq %r14, (%rsp)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8fd34
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7de30
callq 0x57630
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x1e782(%rip), %rsi # 0x9c5c1
leaq 0x1e784(%rip), %rdx # 0x9c5ca
callq 0x5c0d2
leaq 0x70(%rbx), %rdx
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x90136
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7de6c
callq 0x57630
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x1ddcd(%rip), %rsi # 0x9bc48
leaq 0x1ddce(%rip), %rdx # 0x9bc50
callq 0x5c0d2
leaq 0x78(%rbx), %rdx
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x90136
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7dea8
callq 0x57630
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x1e714(%rip), %rsi # 0x9c5cb
leaq 0x1e71d(%rip), %rdx # 0x9c5db
callq 0x5c0d2
leaq 0x80(%rbx), %rdx
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x90136
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7dee7
callq 0x57630
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
cmpl $0x1, %eax
jne 0x7df38
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x1e6d7(%rip), %rsi # 0x9c5dc
leaq 0x1e6e1(%rip), %rdx # 0x9c5ed
callq 0x5c0d2
addq $0x88, %rbx
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x902d2
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7df38
callq 0x57630
movq %r14, %rdi
callq 0x84bf4
movq %rsp, %rdi
callq 0x9008c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7df60
jmp 0x7df97
jmp 0x7df60
jmp 0x7df97
jmp 0x7df60
jmp 0x7df97
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7df9a
callq 0x57630
jmp 0x7df9a
jmp 0x7df97
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9008c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7dfa2
callq 0x57630
jmp 0x7dfa2
movq %rax, %rbx
jmp 0x7dfa2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9008c
movq %rbx, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&)
|
virtual bool sectionStarted (
SectionInfo const& sectionInfo,
Counts& assertions
)
{
std::ostringstream oss;
oss << sectionInfo.name << "@" << sectionInfo.lineInfo;
ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, oss.str() );
if( !sectionTracker.isOpen() )
return false;
m_activeSections.push_back( §ionTracker );
m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
m_reporter->sectionStarting( sectionInfo );
assertions = m_totals.assertions;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x578b0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x57750
movq %rax, %r13
leaq 0x1c64b(%rip), %rsi # 0x9b7f9
movl $0x1, %edx
movq %rax, %rdi
callq 0x57750
leaq 0x40(%r15), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x73028
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x57a80
leaq 0x200(%r14), %rdi
movq %rsp, %rsi
callq 0x80402
movq %rax, %r13
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f1fc
callq 0x57630
movq (%r13), %rax
movq %r13, %rdi
callq *0x38(%rax)
movl %eax, %ebp
testb %al, %al
je 0x7f27c
movq %r13, (%rsp)
movq 0x1f0(%r14), %rsi
cmpq 0x1f8(%r14), %rsi
je 0x7f22d
movq %r13, (%rsi)
addq $0x8, 0x1f0(%r14)
jmp 0x7f23c
leaq 0x1e8(%r14), %rdi
movq %rsp, %rdx
callq 0x80544
leaq 0x180(%r14), %rdi
movq %r12, %rsi
callq 0x57390
movq 0x60(%r15), %rax
movq %rax, 0x1a0(%r14)
movq 0x140(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x48(%rax)
movq 0x120(%r14), %rax
movq %rax, 0x10(%rbx)
movups 0x110(%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x3ece5(%rip), %rsi # 0xbdf68
leaq 0x20(%rsp), %rdi
callq 0x57380
leaq 0x90(%rsp), %rdi
callq 0x57220
movl %ebp, %eax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7f2cc
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f2cf
callq 0x57630
jmp 0x7f2cf
jmp 0x7f2cc
jmp 0x7f2cc
movq %rax, %rbx
movq 0x3ec92(%rip), %rsi # 0xbdf68
leaq 0x20(%rsp), %rdi
callq 0x57380
leaq 0x90(%rsp), %rdi
callq 0x57220
movq %rbx, %rdi
callq 0x57bd0
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::RunContext::getCurrentTestName[abi:cxx11]() const
|
virtual std::string getCurrentTestName() const {
return m_activeTestCase
? m_activeTestCase->getTestCaseInfo().name
: "";
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rsi), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
testq %rax, %rax
je 0x7f496
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5c7ae
jmp 0x7f4a8
leaq 0x1d289(%rip), %rdx # 0x9c726
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5c0d2
movq %rbx, %rax
popq %rbx
retq
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::RunContext::handleFatalErrorCondition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
virtual void handleFatalErrorCondition( std::string const& message ) {
ResultBuilder resultBuilder = makeUnexpectedResultBuilder();
resultBuilder.setResultType( ResultWas::FatalErrorCondition );
resultBuilder << message;
resultBuilder.captureExpression();
handleUnfinishedSections();
// Recreate section for test case (as we will lose the one that was in scope)
TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
Counts assertions;
assertions.failed = 1;
SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
m_reporter->sectionEnded( testCaseSectionStats );
TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
Totals deltaTotals;
deltaTotals.testCases.failed = 1;
m_reporter->testCaseEnded( TestCaseStats( testInfo,
deltaTotals,
"",
"",
false ) );
m_totals.testCases.failed++;
testGroupEnded( "", m_totals, 1, 1 );
m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6d0, %rsp # imm = 0x6D0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x180(%rdi), %rdx
movq 0x160(%rdi), %rsi
movq 0x1a8(%rdi), %rcx
movl 0x1c8(%rdi), %r8d
leaq 0x1d239(%rip), %r9 # 0x9c726
leaq 0x430(%rsp), %r15
movq %r15, %rdi
callq 0x76c86
movl $0x210, 0xb0(%r15) # imm = 0x210
leaq 0x550(%rsp), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x57750
leaq 0x430(%rsp), %rdi
callq 0x76f0c
movq %rbx, %rdi
callq 0x80dd2
movq 0x38(%rbx), %rdx
leaq 0xe0(%rdx), %rsi
leaq 0x40(%rdx), %rcx
leaq 0x78(%rsp), %rdi
callq 0x75c30
xorps %xmm0, %xmm0
leaq 0xe0(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq $0x1, 0x8(%rdx)
leaq 0x398(%rsp), %rdi
leaq 0x78(%rsp), %rsi
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x806d0
movq 0x140(%rbx), %rdi
movq (%rdi), %rax
leaq 0x398(%rsp), %rsi
callq *0x60(%rax)
movq 0x38(%rbx), %rsi
leaq 0x288(%rsp), %rdi
callq 0x74778
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq $0x1, 0x60(%rsp)
movq 0x140(%rbx), %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d14f(%rip), %rdx # 0x9c726
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x5c0d2
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1d131(%rip), %rdx # 0x9c726
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x5c0d2
leaq 0xf8(%rsp), %rdi
leaq 0x288(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
xorl %r9d, %r9d
callq 0x80e28
movq (%r14), %rax
leaq 0xf8(%rsp), %rsi
movq %r14, %rdi
callq *0x68(%rax)
leaq 0xf8(%rsp), %rdi
callq 0x78864
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7f651
callq 0x57630
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x7f660
callq 0x57630
incq 0x130(%rbx)
leaq 0x108(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1d0ac(%rip), %rdx # 0x9c726
leaq 0xf8(%rsp), %rdi
movq %rdx, %rsi
callq 0x5c0d2
leaq 0x110(%rbx), %r14
leaq 0xf8(%rsp), %rsi
movl $0x1, %ecx
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x79bda
movq 0xf8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7f6c1
callq 0x57630
movq 0x140(%rbx), %r15
leaq 0x3c571(%rip), %r13 # 0xbbc40
leaq 0x100(%rsp), %rdi
movq %r13, -0x8(%rdi)
leaq 0x110(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq %rsi, %rdx
callq 0x5c7ae
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
leaq 0xf8(%rsp), %rsi
movups %xmm2, 0x48(%rsi)
movups %xmm1, 0x38(%rsi)
movups %xmm0, 0x28(%rsi)
movb $0x0, 0x58(%rsi)
movq (%r15), %rax
movq %r15, %rdi
callq *0x78(%rax)
movq %r13, 0xf8(%rsp)
movq 0x100(%rsp), %rdi
cmpq %r12, %rdi
je 0x7f741
callq 0x57630
leaq 0x378(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f757
callq 0x57630
leaq 0x358(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f76d
callq 0x57630
leaq 0x318(%rsp), %rdi
callq 0x828b2
leaq 0x2e8(%rsp), %rbx
movq %rbx, %rdi
callq 0x828b2
movq -0x20(%rbx), %rdi
leaq 0x2d8(%rsp), %rax
cmpq %rax, %rdi
je 0x7f7a0
callq 0x57630
leaq 0x2b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f7b6
callq 0x57630
leaq 0x298(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f7cc
callq 0x57630
leaq 0x398(%rsp), %rdi
callq 0x7880a
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f7ef
callq 0x57630
leaq 0xa8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f805
callq 0x57630
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f81b
callq 0x57630
leaq 0x430(%rsp), %rdi
callq 0x69c2e
addq $0x6d0, %rsp # imm = 0x6D0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r13, 0xf8(%rsp)
movq 0x100(%rsp), %rdi
cmpq %r12, %rdi
jne 0x7f896
jmp 0x7f8a0
jmp 0x7f89d
movq %rax, %rbx
movq 0xf8(%rsp), %rdi
jmp 0x7f891
jmp 0x7f89d
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x78864
jmp 0x7f879
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7f88c
callq 0x57630
jmp 0x7f88c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x7f8a0
callq 0x57630
jmp 0x7f8a0
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
callq 0x7a514
jmp 0x7f8b4
jmp 0x7f8b1
movq %rax, %rbx
leaq 0x398(%rsp), %rdi
callq 0x7880a
leaq 0x78(%rsp), %rdi
callq 0x7a690
jmp 0x7f8d7
movq %rax, %rbx
jmp 0x7f8c1
jmp 0x7f8d4
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
callq 0x69c2e
movq %rbx, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::AssertionStats::AssertionStats(Catch::AssertionResult const&, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> const&, Catch::Totals const&)
|
AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
Totals const& _totals )
: assertionResult( _assertionResult ),
infoMessages( _infoMessages ),
totals( _totals )
{
if( assertionResult.hasMessage() ) {
// Copy message into messages list.
// !TBD This should have been done earlier, somewhere
MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
builder << assertionResult.getMessage();
builder.m_info.message = builder.m_stream.str();
infoMessages.push_back( builder.m_info );
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x240, %rsp # imm = 0x240
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
leaq 0x3c216(%rip), %rax # 0xbbbc0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x7fc58
leaq 0xc0(%r15), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x7fd74
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0xf8(%r15)
movups %xmm1, 0xe8(%r15)
movups %xmm0, 0xd8(%r15)
cmpq $0x0, 0xa0(%r15)
je 0x7fb6a
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x5c7ae
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x5c7ae
movq 0x48(%r15), %rax
leaq 0x8(%rsp), %rdx
movq %rax, 0x20(%rdx)
movl 0xb8(%r15), %ecx
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7fe06
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7fa71
callq 0x57630
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x7fa80
callq 0x57630
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq 0x98(%r15), %rsi
movq 0xa0(%r15), %rdx
addq %rsi, %rdx
callq 0x5c7ae
leaq 0xc8(%rsp), %r15
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x57750
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7fac7
callq 0x57630
leaq 0xd0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x57a80
leaq 0xa0(%rsp), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x577f0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x7fafc
callq 0x57630
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x7fe36
movq 0x3e458(%rip), %rsi # 0xbdf68
movq %r15, %rdi
callq 0x57380
leaq 0x138(%rsp), %rbx
movq %rbx, %rdi
callq 0x57220
movq -0x98(%rbx), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x7fb41
callq 0x57630
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7fb57
callq 0x57630
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7fb6a
callq 0x57630
addq $0x240, %rsp # imm = 0x240
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7fb93
jmp 0x7fb93
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7fb96
callq 0x57630
jmp 0x7fb96
movq %rax, %r15
leaq 0x50(%rsp), %rdi
callq 0x7fe60
jmp 0x7fbcd
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7fbb9
callq 0x57630
jmp 0x7fbb9
movq %rax, %r15
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x7fbcd
callq 0x57630
jmp 0x7fbcd
movq %rax, %r15
movq %r14, %rdi
callq 0x7add6
movq %rbx, %rdi
callq 0x74126
movq %r15, %rdi
callq 0x57bd0
movq %rax, %r15
jmp 0x7fbd5
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) {
SectionTracker* section = CATCH_NULL;
ITracker& currentTracker = ctx.currentTracker();
if( ITracker* childTracker = currentTracker.findChild( name ) ) {
assert( childTracker );
assert( childTracker->isSectionTracker() );
section = static_cast<SectionTracker*>( childTracker );
}
else {
section = new SectionTracker( name, ctx, ¤tTracker );
currentTracker.addChild( section );
}
if( !ctx.completedCycle() && !section->isComplete() ) {
section->open();
}
return *section;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x80458
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x80(%rax)
testb %al, %al
jne 0x804d1
leaq 0x1b4b9(%rip), %rdi # 0x9b8f9
leaq 0x1b24a(%rip), %rsi # 0x9b691
leaq 0x1b43c(%rip), %rcx # 0x9b88a
movl $0x165a, %edx # imm = 0x165A
callq 0x57440
movl $0x60, %edi
callq 0x57690
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x3bcd5(%rip), %rax # 0xbc148
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x5c7ae
movq %r14, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4c(%rbx)
leaq 0x3c093(%rip), %rax # 0xbc540
movq %rax, (%rbx)
movq %rsp, %rsi
movq %rbx, (%rsi)
incl 0x8(%rbx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x68(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x804d1
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, 0x10(%r14)
je 0x80503
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x80503
movl $0x1, 0x58(%rbx)
movq 0x30(%rbx), %rax
movq %rbx, 0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x80503
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x80528
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8053b
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x8053b
movq %rax, %rdi
callq 0x5bcbe
movq %rax, %r14
movq %rbx, %rdi
callq 0x57630
movq %r14, %rdi
callq 0x57bd0
nop
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
Catch::SectionStats::SectionStats(Catch::SectionInfo const&, Catch::Counts const&, double, bool)
|
SectionStats( SectionInfo const& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
: sectionInfo( _sectionInfo ),
assertions( _assertions ),
durationInSeconds( _durationInSeconds ),
missingAssertions( _missingAssertions )
{}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x3b4ea(%rip), %rax # 0xbbbe0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%r14)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rdi, 0x8(%rsp)
callq 0x5c7ae
leaq 0x28(%r14), %r13
leaq 0x38(%r14), %rbx
movq %rbx, 0x28(%r14)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x5c7ae
leaq 0x48(%r14), %rdi
leaq 0x58(%r14), %rax
movq %rax, 0x48(%r14)
movq 0x40(%r12), %rsi
movq 0x48(%r12), %rdx
addq %rsi, %rdx
callq 0x5c7ae
movq 0x60(%r12), %rax
movq %rax, 0x68(%r14)
movups (%r15), %xmm0
movups %xmm0, 0x70(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x80(%r14)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x88(%r14)
movb %bpl, 0x90(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r13), %rdi
cmpq %rbx, %rdi
je 0x807b5
callq 0x57630
jmp 0x807b5
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0x807c8
callq 0x57630
movq %r14, %rdi
callq 0x57bd0
|
/basiliscos[P]cpp-bredis/t/catch.hpp
|
nativeFutexWake(void const*, int, unsigned int)
|
int nativeFutexWake(const void *addr, int count, uint32_t wakeMask) {
#ifndef PSHARED
int rv = syscall(
__NR_futex,
addr, /* addr1 */
FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, /* op */
count, /* val */
nullptr, /* timeout */
nullptr, /* addr2 */
wakeMask); /* val3 */
#else
int rv = syscall(
__NR_futex,
addr, /* addr1 */
FUTEX_WAKE_BITSET, /* op */
count, /* val */
nullptr, /* timeout */
nullptr, /* addr2 */
wakeMask); /* val3 */
#endif
/* NOTE: we ignore errors on wake for the case of a futex
guarding its own destruction, similar to this
glibc bug with sem_post/sem_wait:
https://sourceware.org/bugzilla/show_bug.cgi?id=12674 */
if (rv < 0) {
return 0;
}
return rv;
}
|
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %eax
movl $0xca, %edi
movl $0x8a, %edx
xorl %r8d, %r8d
movl %r8d, %r9d
movq %r9, %r8
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4040
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x42d0
movl $0x0, 0x24(%rsp)
jmp 0x42d8
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
/r10a[P]Event-Counts/Futex.cpp
|
nativeFutexWaitImpl(void const*, unsigned int, std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const*, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const*, unsigned int)
|
FutexResult nativeFutexWaitImpl(
const void *addr,
uint32_t expected,
system_clock::time_point const *absSystemTime,
steady_clock::time_point const *absSteadyTime,
uint32_t waitMask) {
assert(absSystemTime == nullptr || absSteadyTime == nullptr);
#ifndef PSHARED
int op = FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG;
#else
int op = FUTEX_WAIT_BITSET;
#endif
struct timespec ts;
struct timespec *timeout = nullptr;
if (absSystemTime != nullptr) {
op |= FUTEX_CLOCK_REALTIME;
ts = timeSpecFromTimePoint(*absSystemTime);
timeout = &ts;
} else if (absSteadyTime != nullptr) {
ts = timeSpecFromTimePoint(*absSteadyTime);
timeout = &ts;
}
// Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET requires an absolute timeout
// value - http://locklessinc.com/articles/futex_cheat_sheet/
int rv = syscall(
__NR_futex,
addr, /* addr1 */
op, /* op */
expected, /* val */
timeout, /* timeout */
nullptr, /* addr2 */
waitMask); /* val3 */
if (rv == 0) {
return FutexResult::AWOKEN;
} else {
switch (errno) {
case ETIMEDOUT:
assert(timeout != nullptr);
return FutexResult::TIMEDOUT;
case EINTR:
return FutexResult::INTERRUPTED;
case EWOULDBLOCK:
return FutexResult::VALUE_CHANGED;
default:
assert(false);
// EINVAL, EACCESS, or EFAULT. EINVAL means there was an invalid
// op (should be impossible) or an invalid timeout (should have
// been sanitized by timeSpecFromTimePoint). EACCESS or EFAULT
// means *addr points to invalid memory, which is unlikely because
// the caller should have segfaulted already. We can either
// crash, or return a value that lets the process continue for
// a bit. We choose the latter. VALUE_CHANGED probably turns the
// caller into a spin lock.
return FutexResult::VALUE_CHANGED;
}
}
}
|
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movb $0x1, %al
cmpq $0x0, 0x78(%rsp)
movb %al, 0x1b(%rsp)
je 0x4330
cmpq $0x0, 0x70(%rsp)
sete %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
testb $0x1, %al
jne 0x433a
jmp 0x433c
jmp 0x435b
leaq 0x1cc1(%rip), %rdi # 0x6004
leaq 0x1cef(%rip), %rsi # 0x6039
movl $0x45, %edx
leaq 0x1d3a(%rip), %rcx # 0x6090
callq 0x4080
movl $0x89, 0x68(%rsp)
movq $0x0, 0x50(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x43c2
movl 0x68(%rsp), %eax
orl $0x100, %eax # imm = 0x100
movl %eax, 0x68(%rsp)
movq 0x78(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4570
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x440b
cmpq $0x0, 0x70(%rsp)
je 0x4409
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4620
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x440b
movq 0x88(%rsp), %rsi
movl 0x68(%rsp), %edx
movl 0x84(%rsp), %ecx
movq 0x50(%rsp), %r8
movl 0x6c(%rsp), %eax
movl $0xca, %edi
xorl %r9d, %r9d
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4040
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x4454
movl $0x1, 0x94(%rsp)
jmp 0x44eb
callq 0x4030
movl (%rax), %eax
movl %eax, 0x14(%rsp)
subl $0x4, %eax
je 0x44b2
jmp 0x4466
movl 0x14(%rsp), %eax
subl $0xb, %eax
je 0x44bf
jmp 0x4471
movl 0x14(%rsp), %eax
subl $0x6e, %eax
jne 0x44cc
jmp 0x447c
cmpq $0x0, 0x50(%rsp)
je 0x4486
jmp 0x44a5
leaq 0x1c89(%rip), %rdi # 0x6116
leaq 0x1ba5(%rip), %rsi # 0x6039
movl $0x68, %edx
leaq 0x1bf0(%rip), %rcx # 0x6090
callq 0x4080
movl $0x3, 0x94(%rsp)
jmp 0x44eb
movl $0x2, 0x94(%rsp)
jmp 0x44eb
movl $0x0, 0x94(%rsp)
jmp 0x44eb
leaq 0x1c56(%rip), %rdi # 0x6129
leaq 0x1b5f(%rip), %rsi # 0x6039
movl $0x6f, %edx
leaq 0x1baa(%rip), %rcx # 0x6090
callq 0x4080
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw (%rax,%rax)
|
/r10a[P]Event-Counts/Futex.cpp
|
timespec timeSpecFromTimePoint<std::chrono::_V2::system_clock>(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::_V2::system_clock::duration>)
|
struct timespec timeSpecFromTimePoint(time_point<Clock> absTime) {
auto epoch = absTime.time_since_epoch();
if (epoch.count() < 0) {
// kernel timespec_valid requires non-negative seconds and nanos in [0,1G)
epoch = Clock::duration::zero();
}
// timespec-safe seconds and nanoseconds;
// chrono::{nano,}seconds are `long long int`
// whereas timespec uses smaller types
using time_t_seconds = duration<std::time_t, seconds::period>;
using long_nanos = duration<long int, nanoseconds::period>;
auto secs = duration_cast<time_t_seconds>(epoch);
auto nanos = duration_cast<long_nanos>(epoch - secs);
struct timespec result = {secs.count(), nanos.count()};
return result;
}
|
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x46d0
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46f0
cmpq $0x0, %rax
jge 0x45ac
callq 0x4700
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x47a0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4770
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x4810
movq %rax, 0x48(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x46f0
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
|
/r10a[P]Event-Counts/Futex.cpp
|
timespec timeSpecFromTimePoint<std::chrono::_V2::steady_clock>(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::_V2::steady_clock::duration>)
|
struct timespec timeSpecFromTimePoint(time_point<Clock> absTime) {
auto epoch = absTime.time_since_epoch();
if (epoch.count() < 0) {
// kernel timespec_valid requires non-negative seconds and nanos in [0,1G)
epoch = Clock::duration::zero();
}
// timespec-safe seconds and nanoseconds;
// chrono::{nano,}seconds are `long long int`
// whereas timespec uses smaller types
using time_t_seconds = duration<std::time_t, seconds::period>;
using long_nanos = duration<long int, nanoseconds::period>;
auto secs = duration_cast<time_t_seconds>(epoch);
auto nanos = duration_cast<long_nanos>(epoch - secs);
struct timespec result = {secs.count(), nanos.count()};
return result;
}
|
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x49b0
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46f0
cmpq $0x0, %rax
jge 0x465c
callq 0x4700
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x47a0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4770
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x4810
movq %rax, 0x48(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x46f0
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
|
/r10a[P]Event-Counts/Futex.cpp
|
notifier(EventCount*)
|
void notifier(EventCount *eventCount) {
for (int i = 0; i < 100; i++) {
std::cout << "Notifying: " << i << std::endl;
eventCount->notify();
std::cout << "Notified: " << i << std::endl;
usleep(100);
}
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x64, 0xc(%rsp)
jge 0x4b2c
movq 0x4525(%rip), %rdi # 0x8fd8
leaq 0x16d6(%rip), %rsi # 0x6190
callq 0x40b0
movq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x4120
movq %rax, %rdi
movq 0x44eb(%rip), %rsi # 0x8fc0
callq 0x40e0
movq 0x10(%rsp), %rdi
callq 0x4ee0
movq 0x44ed(%rip), %rdi # 0x8fd8
leaq 0x16aa(%rip), %rsi # 0x619c
callq 0x40b0
movq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x4120
movq %rax, %rdi
movq 0x44b3(%rip), %rsi # 0x8fc0
callq 0x40e0
movl $0x64, %edi
callq 0x40f0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4aa1
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
|
/r10a[P]Event-Counts/main.cpp
|
main
|
int main(int argc, char **argv) {
EventCount eventCount;
std::thread t1(waiter, &eventCount);
usleep(1);
std::thread t2(notifier, &eventCount);
t1.join();
t2.join();
return 0;
}
|
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4f00
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq -0x1a5(%rip), %rsi # 0x49d0
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4f20
movl $0x1, %edi
callq 0x40f0
jmp 0x4b90
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq -0x111(%rip), %rsi # 0x4a90
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x4f20
jmp 0x4bb2
leaq 0x38(%rsp), %rdi
callq 0x4110
jmp 0x4bbe
leaq 0x18(%rsp), %rdi
callq 0x4110
jmp 0x4bca
movl $0x0, 0x54(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4ff0
leaq 0x38(%rsp), %rdi
callq 0x4ff0
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x4c17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4ff0
leaq 0x38(%rsp), %rdi
callq 0x4ff0
movq 0x28(%rsp), %rdi
callq 0x4130
nopl (%rax,%rax)
|
/r10a[P]Event-Counts/main.cpp
|
EventCount::prepareWait()
|
inline EventCount::Key EventCount::prepareWait() noexcept {
uint64_t prev = val_.fetch_add(kAddWaiter, std::memory_order_acq_rel);
return Key(prev >> kEpochShift);
}
|
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movq $0x1, 0x48(%rsp)
movl $0x4, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %eax
movq 0x48(%rsp), %rcx
movq %rcx, 0x38(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0x4c8f
movq 0x10(%rsp), %rax
leaq 0x14aa(%rip), %rcx # 0x6130
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
jmp 0x4cfb
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
jmp 0x4cfb
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
jmp 0x4cfb
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
jmp 0x4cfb
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
shrq $0x20, %rax
movl %eax, %esi
leaq 0x2c(%rsp), %rdi
callq 0x5010
movl 0x2c(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/r10a[P]Event-Counts/EventCount.hpp
|
EventCount::wait(EventCount::Key)
|
inline void EventCount::wait(Key key) noexcept {
while ((val_.load(std::memory_order_acquire) >> kEpochShift) == key.epoch_) {
futexWait(
reinterpret_cast<Futex<std::atomic> *>(&val_) + kEpochOffset,
key.epoch_);
}
// memory_order_relaxed would suffice for correctness, but the faster
// #waiters gets to 0, the less likely it is that we'll do spurious wakeups
// (and thus system calls)
// uint64_t prev = val_.fetch_add(kSubWaiter, std::memory_order_seq_cst);
// DCHECK_NE((prev & kWaiterMask), 0);
val_.fetch_add(kSubWaiter, std::memory_order_seq_cst);
}
|
subq $0x88, %rsp
movl %esi, 0x44(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
movl $0x2, 0x7c(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x7c(%rsp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0x5090
movl %eax, 0x2c(%rsp)
jmp 0x4d80
movl 0x2c(%rsp), %eax
movl %eax, 0x78(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, 0x1c(%rsp)
decl %eax
subl $0x2, %eax
jb 0x4db3
jmp 0x4d99
movl 0x1c(%rsp), %eax
subl $0x5, %eax
je 0x4dc2
jmp 0x4da4
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x4dd9
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x4dd9
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x70(%rsp)
jmp 0x4dd9
movq %rax, %rdi
callq 0x4850
movq 0x70(%rsp), %rax
shrq $0x20, %rax
movl 0x44(%rsp), %ecx
cmpq %rcx, %rax
jne 0x4e09
movq 0x30(%rsp), %rdi
addq $0x4, %rdi
movl 0x44(%rsp), %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x5030
jmp 0x4e04
jmp 0x4d4a
movq 0x30(%rsp), %rax
movq %rax, 0x68(%rsp)
movq $-0x1, 0x60(%rsp)
movl $0x5, 0x5c(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x5c(%rsp), %eax
movq 0x60(%rsp), %rcx
movq %rcx, 0x50(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0x4e5f
movq 0x10(%rsp), %rax
leaq 0x12ee(%rip), %rcx # 0x6144
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x48(%rsp)
jmp 0x4ecb
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x48(%rsp)
jmp 0x4ecb
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x48(%rsp)
jmp 0x4ecb
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x48(%rsp)
jmp 0x4ecb
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x48(%rsp)
addq $0x88, %rsp
retq
movq %rax, %rdi
callq 0x4850
nopl (%rax,%rax)
|
/r10a[P]Event-Counts/EventCount.hpp
|
EventCount::doNotify(int)
|
inline void EventCount::doNotify(int n) noexcept {
uint64_t prev = val_.fetch_add(kAddEpoch, std::memory_order_acq_rel);
if (UNLIKELY(prev & kWaiterMask)) {
futexWake(reinterpret_cast<Futex<std::atomic> *>(&val_) + kEpochOffset, n);
}
}
|
subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq %rax, 0x50(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x48(%rsp)
movl $0x4, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %eax
movq 0x48(%rsp), %rcx
movq %rcx, 0x38(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0x511d
movq 0x10(%rsp), %rax
leaq 0x1044(%rip), %rcx # 0x6158
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
jmp 0x5189
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
jmp 0x5189
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
jmp 0x5189
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
jmp 0x5189
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0x18(%rsp), %rax
cmpq $0x0, %rax
je 0x51c2
movq (%rsp), %rdi
addq $0x4, %rdi
movl 0x24(%rsp), %esi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x51d0
jmp 0x51c0
jmp 0x51c2
addq $0x58, %rsp
retq
movq %rax, %rdi
callq 0x4850
nop
|
/r10a[P]Event-Counts/EventCount.hpp
|
alsa_stream_get_latency
|
static int
alsa_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
{
snd_pcm_sframes_t delay;
/* This function returns the delay in frames until a frame written using
snd_pcm_writei is sent to the DAC. The DAC delay should be < 1ms anyways.
*/
if (WRAP(snd_pcm_delay)(stm->pcm, &delay)) {
return CUBEB_ERROR;
}
*latency = delay;
return CUBEB_OK;
}
|
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x52423(%rip), %rax # 0x668c8
movq 0x18(%rsp), %rcx
movq 0x38(%rcx), %rdi
leaq 0x8(%rsp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x144c4
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x144da
movq 0x8(%rsp), %rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_alsa.c
|
sndio_stream_start
|
static int
sndio_stream_start(cubeb_stream * s)
{
int err;
DPR("sndio_stream_start()\n");
s->active = 1;
err = pthread_create(&s->th, NULL, sndio_mainloop, s);
if (err) {
s->active = 0;
return CUBEB_ERROR;
}
return CUBEB_OK;
}
|
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
jmp 0x15abb
movq 0x8(%rsp), %rax
movl $0x1, 0x4c(%rax)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x190(%rip), %rdx # 0x15c70
callq 0x6ab0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x15b06
movq 0x8(%rsp), %rax
movl $0x0, 0x4c(%rax)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x15b0e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_sndio.c
|
sndio_stream_set_volume
|
static int
sndio_stream_set_volume(cubeb_stream * s, float volume)
{
DPR("sndio_stream_set_volume(%f)\n", volume);
pthread_mutex_lock(&s->mtx);
if (volume < 0.)
volume = 0.;
else if (volume > 1.0)
volume = 1.;
s->volume = volume;
pthread_mutex_unlock(&s->mtx);
return CUBEB_OK;
}
|
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
jmp 0x15bc1
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x6870
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x15bed
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x15c15
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x2e5c9(%rip), %xmm1 # 0x441c8
ucomisd %xmm1, %xmm0
jbe 0x15c13
movss 0x2fc2b(%rip), %xmm0 # 0x45838
movss %xmm0, 0xc(%rsp)
jmp 0x15c15
movss 0xc(%rsp), %xmm0
movq 0x10(%rsp), %rax
movss %xmm0, 0xa0(%rax)
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x6360
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
|
/kinetiknz[P]cubeb/src/cubeb_sndio.c
|
sndio_mainloop
|
static void *
sndio_mainloop(void * arg)
{
struct pollfd * pfds;
cubeb_stream * s = arg;
int n, eof = 0, prime, nfds, events, revents, state = CUBEB_STATE_STARTED;
size_t pstart = 0, pend = 0, rstart = 0, rend = 0;
long nfr;
nfds = WRAP(sio_nfds)(s->hdl);
pfds = calloc(nfds, sizeof(struct pollfd));
if (pfds == NULL)
return NULL;
DPR("sndio_mainloop()\n");
s->state_cb(s, s->arg, CUBEB_STATE_STARTED);
pthread_mutex_lock(&s->mtx);
if (!WRAP(sio_start)(s->hdl)) {
pthread_mutex_unlock(&s->mtx);
free(pfds);
return NULL;
}
DPR("sndio_mainloop(), started\n");
if (s->mode & SIO_PLAY) {
pstart = pend = s->nfr * s->pbpf;
prime = s->nblks;
if (s->mode & SIO_REC) {
memset(s->rbuf, 0, s->nfr * s->rbpf);
rstart = rend = s->nfr * s->rbpf;
}
} else {
prime = 0;
rstart = 0;
rend = s->nfr * s->rbpf;
}
for (;;) {
if (!s->active) {
DPR("sndio_mainloop() stopped\n");
state = CUBEB_STATE_STOPPED;
break;
}
/* do we have a complete block? */
if ((!(s->mode & SIO_PLAY) || pstart == pend) &&
(!(s->mode & SIO_REC) || rstart == rend)) {
if (eof) {
DPR("sndio_mainloop() drained\n");
state = CUBEB_STATE_DRAINED;
break;
}
if ((s->mode & SIO_REC) && s->conv)
s16_to_float(s->rbuf, s->nfr * s->rchan);
/* invoke call-back, it returns less that s->nfr if done */
pthread_mutex_unlock(&s->mtx);
nfr = s->data_cb(s, s->arg, s->rbuf, s->pbuf, s->nfr);
pthread_mutex_lock(&s->mtx);
if (nfr < 0) {
DPR("sndio_mainloop() cb err\n");
state = CUBEB_STATE_ERROR;
break;
}
s->swpos += nfr;
/* was this last call-back invocation (aka end-of-stream) ? */
if (nfr < s->nfr) {
if (!(s->mode & SIO_PLAY) || nfr == 0) {
state = CUBEB_STATE_DRAINED;
break;
}
/* need to write (aka drain) the partial play block we got */
pend = nfr * s->pbpf;
eof = 1;
}
if (prime > 0)
prime--;
if (s->mode & SIO_PLAY) {
if (s->conv)
float_to_s16(s->pbuf, nfr * s->pchan, s->volume);
else
s16_setvol(s->pbuf, nfr * s->pchan, s->volume);
}
if (s->mode & SIO_REC)
rstart = 0;
if (s->mode & SIO_PLAY)
pstart = 0;
}
events = 0;
if ((s->mode & SIO_REC) && rstart < rend && prime == 0)
events |= POLLIN;
if ((s->mode & SIO_PLAY) && pstart < pend)
events |= POLLOUT;
nfds = WRAP(sio_pollfd)(s->hdl, pfds, events);
if (nfds > 0) {
pthread_mutex_unlock(&s->mtx);
n = poll(pfds, nfds, -1);
pthread_mutex_lock(&s->mtx);
if (n < 0)
continue;
}
revents = WRAP(sio_revents)(s->hdl, pfds);
if (revents & POLLHUP) {
state = CUBEB_STATE_ERROR;
break;
}
if (revents & POLLOUT) {
n = WRAP(sio_write)(s->hdl, s->pbuf + pstart, pend - pstart);
if (n == 0 && WRAP(sio_eof)(s->hdl)) {
DPR("sndio_mainloop() werr\n");
state = CUBEB_STATE_ERROR;
break;
}
pstart += n;
}
if (revents & POLLIN) {
n = WRAP(sio_read)(s->hdl, s->rbuf + rstart, rend - rstart);
if (n == 0 && WRAP(sio_eof)(s->hdl)) {
DPR("sndio_mainloop() rerr\n");
state = CUBEB_STATE_ERROR;
break;
}
rstart += n;
}
/* skip rec block, if not recording (yet) */
if (prime > 0 && (s->mode & SIO_REC))
rstart = rend;
}
WRAP(sio_stop)(s->hdl);
s->hwpos = s->swpos;
pthread_mutex_unlock(&s->mtx);
s->state_cb(s, s->arg, state);
free(pfds);
return NULL;
}
|
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x40(%rsp)
movl $0x0, 0x2c(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x50d0a(%rip), %rax # 0x669c8
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
callq *%rax
movl %eax, 0x38(%rsp)
movslq 0x38(%rsp), %rdi
movl $0x8, %esi
callq 0x62e0
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x15cf7
movq $0x0, 0x60(%rsp)
jmp 0x162dc
jmp 0x15cf9
jmp 0x15cfb
movq 0x48(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x48(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x8(%rcx), %rsi
xorl %edx, %edx
callq *%rax
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x6870
movq 0x50cd2(%rip), %rax # 0x66a00
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
jne 0x15d64
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x6360
movq 0x50(%rsp), %rdi
callq 0x6670
movq $0x0, 0x60(%rsp)
jmp 0x162dc
jmp 0x15d66
jmp 0x15d68
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15df5
movq 0x48(%rsp), %rax
movl 0x68(%rax), %eax
movq 0x48(%rsp), %rcx
imull 0x70(%rcx), %eax
movl %eax, %eax
movq %rax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movl 0x7c(%rax), %eax
movl %eax, 0x3c(%rsp)
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x15df3
movq 0x48(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x48(%rsp), %rax
movl 0x68(%rax), %eax
movq 0x48(%rsp), %rcx
imull 0x6c(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x6240
movq 0x48(%rsp), %rax
movl 0x68(%rax), %eax
movq 0x48(%rsp), %rcx
imull 0x6c(%rcx), %eax
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
jmp 0x15e1e
movl $0x0, 0x3c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x48(%rsp), %rax
movl 0x68(%rax), %eax
movq 0x48(%rsp), %rcx
imull 0x6c(%rcx), %eax
movl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x15e20
movq 0x48(%rsp), %rax
cmpl $0x0, 0x4c(%rax)
jne 0x15e3c
jmp 0x15e2d
jmp 0x15e2f
movl $0x1, 0x2c(%rsp)
jmp 0x16271
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15e5c
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x16065
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x15e7c
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x16065
cmpl $0x0, 0x40(%rsp)
je 0x15e94
jmp 0x15e85
jmp 0x15e87
movl $0x2, 0x2c(%rsp)
jmp 0x16271
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x15ed2
movq 0x48(%rsp), %rax
cmpl $0x0, 0x50(%rax)
je 0x15ed2
movq 0x48(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x48(%rsp), %rax
movl 0x68(%rax), %eax
movq 0x48(%rsp), %rcx
imull 0x74(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x162f0
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x6360
movq 0x48(%rsp), %rax
movq 0x90(%rax), %rax
movq 0x48(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq 0x48(%rsp), %rcx
movq 0x58(%rcx), %rdx
movq 0x48(%rsp), %rcx
movq 0x60(%rcx), %rcx
movq 0x48(%rsp), %r8
movl 0x68(%r8), %r8d
callq *%rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x6870
cmpq $0x0, (%rsp)
jge 0x15f41
jmp 0x15f32
jmp 0x15f34
movl $0x3, 0x2c(%rsp)
jmp 0x16271
movq (%rsp), %rcx
movq 0x48(%rsp), %rax
addq 0x88(%rax), %rcx
movq %rcx, 0x88(%rax)
movq (%rsp), %rax
movq 0x48(%rsp), %rcx
movl 0x68(%rcx), %ecx
cmpq %rcx, %rax
jge 0x15faa
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x15f80
cmpq $0x0, (%rsp)
jne 0x15f8d
movl $0x2, 0x2c(%rsp)
jmp 0x16271
movq (%rsp), %rax
movq 0x48(%rsp), %rcx
movl 0x70(%rcx), %ecx
imulq %rcx, %rax
movq %rax, 0x18(%rsp)
movl $0x1, 0x40(%rsp)
cmpl $0x0, 0x3c(%rsp)
jle 0x15fbc
movl 0x3c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x3c(%rsp)
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16031
movq 0x48(%rsp), %rax
cmpl $0x0, 0x50(%rax)
je 0x16004
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq (%rsp), %rsi
movq 0x48(%rsp), %rax
movl 0x78(%rax), %eax
imulq %rax, %rsi
movq 0x48(%rsp), %rax
movss 0xa0(%rax), %xmm0
callq 0x16390
jmp 0x1602f
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq (%rsp), %rsi
movq 0x48(%rsp), %rax
movl 0x78(%rax), %eax
imulq %rax, %rsi
movq 0x48(%rsp), %rax
movss 0xa0(%rax), %xmm0
callq 0x16460
jmp 0x16031
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1604a
movq $0x0, 0x10(%rsp)
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16063
movq $0x0, 0x20(%rsp)
jmp 0x16065
movl $0x0, 0x34(%rsp)
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1609b
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x1609b
cmpl $0x0, 0x3c(%rsp)
jne 0x1609b
movl 0x34(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x34(%rsp)
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x160c2
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x160c2
movl 0x34(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x34(%rsp)
movq 0x50917(%rip), %rax # 0x669e0
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
movq 0x50(%rsp), %rsi
movl 0x34(%rsp), %edx
callq *%rax
movl %eax, 0x38(%rsp)
cmpl $0x0, 0x38(%rsp)
jle 0x1612a
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x6360
movq 0x50(%rsp), %rdi
movslq 0x38(%rsp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x68c0
movl %eax, 0x44(%rsp)
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x6870
cmpl $0x0, 0x44(%rsp)
jge 0x16128
jmp 0x15e20
jmp 0x1612a
movq 0x508bf(%rip), %rax # 0x669f0
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
movq 0x50(%rsp), %rsi
callq *%rax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1615e
movl $0x3, 0x2c(%rsp)
jmp 0x16271
movl 0x30(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x161d6
movq 0x5089f(%rip), %rax # 0x66a10
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
movq 0x48(%rsp), %rcx
movq 0x60(%rcx), %rsi
addq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq 0x20(%rsp), %rdx
callq *%rax
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0x161c7
movq 0x5080a(%rip), %rax # 0x669b0
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x161c7
jmp 0x161b8
jmp 0x161ba
movl $0x3, 0x2c(%rsp)
jmp 0x16271
movslq 0x44(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x30(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1624b
movq 0x507ff(%rip), %rax # 0x669e8
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
movq 0x48(%rsp), %rcx
movq 0x58(%rcx), %rsi
addq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
subq 0x10(%rsp), %rdx
callq *%rax
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0x1623c
movq 0x50792(%rip), %rax # 0x669b0
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x1623c
jmp 0x16230
jmp 0x16232
movl $0x3, 0x2c(%rsp)
jmp 0x16271
movslq 0x44(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x3c(%rsp)
jle 0x1626c
movq 0x48(%rsp), %rax
movl 0x48(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1626c
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x15e20
movq 0x50790(%rip), %rax # 0x66a08
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
callq *%rax
movq 0x48(%rsp), %rax
movq 0x88(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0x6360
movq 0x48(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x48(%rsp), %rdi
movq 0x48(%rsp), %rcx
movq 0x8(%rcx), %rsi
movl 0x2c(%rsp), %edx
callq *%rax
movq 0x50(%rsp), %rdi
callq 0x6670
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_sndio.c
|
s16_to_float
|
static void
s16_to_float(void * ptr, long nsamp)
{
int16_t * src = ptr;
float * dst = ptr;
src += nsamp;
dst += nsamp;
while (nsamp-- > 0)
*(--dst) = (1. / 32768) * *(--src);
}
|
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
shlq %rax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
shlq $0x2, %rax
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
jle 0x1638b
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x2, %rcx
movq %rcx, -0x18(%rsp)
movswl -0x2(%rax), %eax
cvtsi2sd %eax, %xmm1
movsd 0x2fc0d(%rip), %xmm0 # 0x45f78
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x20(%rsp)
movss %xmm0, -0x4(%rax)
jmp 0x16333
retq
nopl (%rax)
|
/kinetiknz[P]cubeb/src/cubeb_sndio.c
|
float_to_s16
|
static void
float_to_s16(void * ptr, long nsamp, float volume)
{
int16_t * dst = ptr;
float * src = ptr;
float mult = volume * 32768;
int s;
while (nsamp-- > 0) {
s = lrintf(*(src++) * mult);
if (s < -32768)
s = -32768;
else if (s > 32767)
s = 32767;
*(dst++) = s;
}
}
|
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movss 0x2fbb4(%rip), %xmm0 # 0x45f74
mulss 0x24(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rsp)
cmpq $0x0, %rax
jle 0x1644c
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rsp)
movss (%rax), %xmm0
mulss 0xc(%rsp), %xmm0
callq 0x6370
movl %eax, 0x8(%rsp)
cmpl $0xffff8000, 0x8(%rsp) # imm = 0xFFFF8000
jge 0x1641b
movl $0xffff8000, 0x8(%rsp) # imm = 0xFFFF8000
jmp 0x1642f
cmpl $0x7fff, 0x8(%rsp) # imm = 0x7FFF
jle 0x1642d
movl $0x7fff, 0x8(%rsp) # imm = 0x7FFF
jmp 0x1642f
movl 0x8(%rsp), %eax
movw %ax, %cx
movq 0x18(%rsp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, 0x18(%rsp)
movw %cx, (%rax)
jmp 0x163cc
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_sndio.c
|
s16_setvol
|
static void
s16_setvol(void * ptr, long nsamp, float volume)
{
int16_t * dst = ptr;
int32_t mult = volume * 32768;
int32_t s;
while (nsamp-- > 0) {
s = *dst;
s = (s * mult) >> 15;
*(dst++) = s;
}
}
|
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movss %xmm0, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movss 0x2faf2(%rip), %xmm0 # 0x45f74
mulss -0x14(%rsp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
jle 0x164e0
movq -0x20(%rsp), %rax
movswl (%rax), %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
imull -0x24(%rsp), %eax
sarl $0xf, %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %eax
movw %ax, %cx
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x20(%rsp)
movw %cx, (%rax)
jmp 0x16490
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_sndio.c
|
cubeb_channel_layout_nb_channels
|
unsigned int
cubeb_channel_layout_nb_channels(cubeb_channel_layout x)
{
#if __GNUC__ || __clang__
return __builtin_popcount(x);
#else
x -= (x >> 1) & 0x55555555;
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
x = (x + (x >> 4)) & 0x0F0F0F0F;
x += x >> 8;
return (x + (x >> 16)) & 0x3F;
#endif
}
|
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %ecx
movl %ecx, %eax
shrl %eax
andl $0x55555555, %eax # imm = 0x55555555
subl %eax, %ecx
movl %ecx, %eax
andl $0x33333333, %eax # imm = 0x33333333
shrl $0x2, %ecx
andl $0x33333333, %ecx # imm = 0x33333333
addl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
addl %ecx, %eax
andl $0xf0f0f0f, %eax # imm = 0xF0F0F0F
imull $0x1010101, %eax, %eax # imm = 0x1010101
shrl $0x18, %eax
retq
nopl (%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_mixer.cpp
|
MixerContext::init()
|
int
MixerContext::init()
{
int r = auto_matrix();
if (r) {
return r;
}
// Determine if matrix operation would overflow
if (_format == CUBEB_SAMPLE_S16NE) {
int maxsum = 0;
for (uint32_t i = 0; i < _out_ch_count; i++) {
double rem = 0;
int sum = 0;
for (uint32_t j = 0; j < _in_ch_count; j++) {
double target = _matrix[i][j] * 32768 + rem;
int value = lrintf(target);
rem += target - value;
sum += std::abs(value);
}
maxsum = std::max(maxsum, sum);
}
if (maxsum > 32768) {
_clipping = true;
}
}
// FIXME quantize for integers
for (uint32_t i = 0; i < CHANNELS_MAX; i++) {
int ch_in = 0;
for (uint32_t j = 0; j < CHANNELS_MAX; j++) {
_matrix32[i][j] = lrintf(_matrix[i][j] * 32768);
if (_matrix[i][j]) {
_matrix_ch[i][++ch_in] = j;
}
}
_matrix_ch[i][0] = ch_in;
}
return 0;
}
|
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x16530
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x170e0
movl 0x44(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x1731d
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x17203
movl $0x0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x10(%rcx), %eax
jae 0x171eb
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x8(%rsp), %rcx
movl 0x28(%rsp), %eax
cmpl 0xc(%rcx), %eax
jae 0x171c6
movq 0x8(%rsp), %rax
addq $0x20, %rax
movl 0x3c(%rsp), %ecx
shlq $0x8, %rcx
addq %rcx, %rax
movl 0x28(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x2eeea(%rip), %xmm2 # 0x46050
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x6370
movl %eax, 0x1c(%rsp)
movsd 0x20(%rsp), %xmm0
cvtsi2sdl 0x1c(%rsp), %xmm1
subsd %xmm1, %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x17129
leaq 0x40(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x17f90
movl (%rax), %eax
movl %eax, 0x40(%rsp)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x170fe
cmpl $0x8000, 0x40(%rsp) # imm = 0x8000
jle 0x17201
movq 0x8(%rsp), %rax
movb $0x1, 0x4440(%rax)
jmp 0x17203
movl $0x0, 0x18(%rsp)
cmpl $0x20, 0x18(%rsp)
jae 0x17315
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x20, 0x10(%rsp)
jae 0x172e9
movq 0x8(%rsp), %rax
addq $0x20, %rax
movl 0x18(%rsp), %ecx
shlq $0x8, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movsd 0x2edff(%rip), %xmm0 # 0x46050
mulsd (%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x6370
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, %esi
movq %rax, %rcx
addq $0x3020, %rcx # imm = 0x3020
movl 0x18(%rsp), %edx
shlq $0x7, %rdx
addq %rdx, %rcx
movl 0x10(%rsp), %edx
movl %esi, (%rcx,%rdx,4)
addq $0x20, %rax
movl 0x18(%rsp), %ecx
shlq $0x8, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x172aa
jp 0x172aa
jmp 0x172d7
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
movb %cl, %dl
addq $0x4020, %rax # imm = 0x4020
movl 0x18(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rsp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x172d9
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x17226
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
addq $0x4020, %rax # imm = 0x4020
movl 0x18(%rsp), %edx
imulq $0x21, %rdx, %rdx
addq %rdx, %rax
movb %cl, (%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1720b
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_mixer.cpp
|
cubeb_channel_layout_check(unsigned int, unsigned int)
|
static cubeb_channel_layout
cubeb_channel_layout_check(cubeb_channel_layout l, uint32_t c)
{
if (l == CUBEB_LAYOUT_UNDEFINED) {
switch (c) {
case 1:
return CUBEB_LAYOUT_MONO;
case 2:
return CUBEB_LAYOUT_STEREO;
}
}
return l;
}
|
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0x1743f
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
subl $0x1, %eax
je 0x17429
jmp 0x1741e
movl -0x10(%rsp), %eax
subl $0x2, %eax
je 0x17433
jmp 0x1743d
movl $0x4, -0x4(%rsp)
jmp 0x17447
movl $0x3, -0x4(%rsp)
jmp 0x17447
jmp 0x1743f
movl -0x8(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
|
/kinetiknz[P]cubeb/src/cubeb_mixer.cpp
|
int rematrix<float, float, 32ul, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(float)&>(MixerContext const*, float*, float const*, float const (&) [32ul][32ul], cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(float)&, unsigned int)
|
static int
rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn,
const TYPE_COEFF (&matrix_coeff)[COLS][COLS], F && aF, uint32_t frames)
{
static_assert(
std::is_same<TYPE_COEFF, decltype(aF(matrix_coeff[0][0]))>::value,
"function must return the same type as used by matrix_coeff");
for (uint32_t out_i = 0; out_i < s->_out_ch_count; out_i++) {
TYPE * out = aOut + out_i;
switch (s->_matrix_ch[out_i][0]) {
case 0:
for (uint32_t i = 0; i < frames; i++) {
out[i * s->_out_ch_count] = 0;
}
break;
case 1: {
int in_i = s->_matrix_ch[out_i][1];
copy(out, s->_out_ch_count, aIn + in_i, s->_in_ch_count,
matrix_coeff[out_i][in_i], aF, frames);
} break;
case 2:
sum2(out, s->_out_ch_count, aIn + s->_matrix_ch[out_i][1],
aIn + s->_matrix_ch[out_i][2], s->_in_ch_count,
matrix_coeff[out_i][s->_matrix_ch[out_i][1]],
matrix_coeff[out_i][s->_matrix_ch[out_i][2]], aF, frames);
break;
default:
for (uint32_t i = 0; i < frames; i++) {
TYPE_COEFF v = 0;
for (uint32_t j = 0; j < s->_matrix_ch[out_i][0]; j++) {
uint32_t in_i = s->_matrix_ch[out_i][1 + j];
v += *(aIn + in_i + i * s->_in_ch_count) * matrix_coeff[out_i][in_i];
}
out[i * s->_out_ch_count] = aF(v);
}
break;
}
}
return 0;
}
|
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl %r9d, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
movq 0x60(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x1779b
movq 0x58(%rsp), %rax
movl 0x38(%rsp), %ecx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movl 0x38(%rsp), %ecx
movq %rcx, %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movzbl 0x4020(%rax,%rcx), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x174e0
jmp 0x174c3
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x17520
jmp 0x174ce
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0x17594
jmp 0x17679
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x1751b
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %ecx
movq 0x60(%rsp), %rdx
imull 0x10(%rdx), %ecx
movl %ecx, %ecx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x174e8
jmp 0x17789
movq 0x60(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x38(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x50(%rsp), %rdx
movslq 0x28(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq 0x60(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x48(%rsp), %rax
movl 0x38(%rsp), %r8d
shlq $0x7, %r8
addq %r8, %rax
movslq 0x28(%rsp), %r8
movss (%rax,%r8,4), %xmm0
movq 0x40(%rsp), %r8
movl 0x3c(%rsp), %r9d
callq 0x188d0
jmp 0x17789
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x50(%rsp), %rdx
movq 0x60(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x38(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %eax
cltq
shlq $0x2, %rax
addq %rax, %rdx
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x38(%rsp), %r8d
imulq $0x21, %r8, %r8
addq %r8, %rax
movzbl 0x2(%rax), %eax
cltq
shlq $0x2, %rax
addq %rax, %rcx
movq 0x60(%rsp), %rax
movl 0xc(%rax), %r8d
movq 0x48(%rsp), %rax
movl 0x38(%rsp), %r9d
shlq $0x7, %r9
addq %r9, %rax
movq 0x60(%rsp), %r9
addq $0x4020, %r9 # imm = 0x4020
movl 0x38(%rsp), %r10d
imulq $0x21, %r10, %r10
addq %r10, %r9
movzbl 0x1(%r9), %r9d
movss (%rax,%r9,4), %xmm0
movq 0x48(%rsp), %rax
movl 0x38(%rsp), %r9d
shlq $0x7, %r9
addq %r9, %rax
movq 0x60(%rsp), %r9
addq $0x4020, %r9 # imm = 0x4020
movl 0x38(%rsp), %r10d
imulq $0x21, %r10, %r10
addq %r10, %r9
movzbl 0x2(%r9), %r9d
movss (%rax,%r9,4), %xmm1
movq 0x40(%rsp), %r9
movl 0x3c(%rsp), %eax
movl %eax, (%rsp)
callq 0x18970
jmp 0x17789
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jae 0x17787
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x60(%rsp), %rcx
addq $0x4020, %rcx # imm = 0x4020
movl 0x38(%rsp), %edx
imulq $0x21, %rdx, %rdx
addq %rdx, %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jae 0x1774e
movq 0x60(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x38(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x18(%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movl 0x24(%rsp), %ecx
movq 0x60(%rsp), %rdx
imull 0xc(%rdx), %ecx
movl %ecx, %ecx
movss (%rax,%rcx,4), %xmm0
movq 0x48(%rsp), %rax
movl 0x38(%rsp), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
movl 0x18(%rsp), %ecx
movss (%rax,%rcx,4), %xmm2
movss 0x20(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x176a0
movq 0x40(%rsp), %rdi
movss 0x20(%rsp), %xmm0
callq 0x18a50
movq 0x30(%rsp), %rax
movl 0x24(%rsp), %ecx
movq 0x60(%rsp), %rdx
imull 0x10(%rdx), %ecx
movl %ecx, %ecx
movss %xmm0, (%rax,%rcx,4)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x17681
jmp 0x17789
jmp 0x1778b
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x1747a
xorl %eax, %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_mixer.cpp
|
int rematrix<short, int, 32ul, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(int)&>(MixerContext const*, short*, short const*, int const (&) [32ul][32ul], cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(int)&, unsigned int)
|
static int
rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn,
const TYPE_COEFF (&matrix_coeff)[COLS][COLS], F && aF, uint32_t frames)
{
static_assert(
std::is_same<TYPE_COEFF, decltype(aF(matrix_coeff[0][0]))>::value,
"function must return the same type as used by matrix_coeff");
for (uint32_t out_i = 0; out_i < s->_out_ch_count; out_i++) {
TYPE * out = aOut + out_i;
switch (s->_matrix_ch[out_i][0]) {
case 0:
for (uint32_t i = 0; i < frames; i++) {
out[i * s->_out_ch_count] = 0;
}
break;
case 1: {
int in_i = s->_matrix_ch[out_i][1];
copy(out, s->_out_ch_count, aIn + in_i, s->_in_ch_count,
matrix_coeff[out_i][in_i], aF, frames);
} break;
case 2:
sum2(out, s->_out_ch_count, aIn + s->_matrix_ch[out_i][1],
aIn + s->_matrix_ch[out_i][2], s->_in_ch_count,
matrix_coeff[out_i][s->_matrix_ch[out_i][1]],
matrix_coeff[out_i][s->_matrix_ch[out_i][2]], aF, frames);
break;
default:
for (uint32_t i = 0; i < frames; i++) {
TYPE_COEFF v = 0;
for (uint32_t j = 0; j < s->_matrix_ch[out_i][0]; j++) {
uint32_t in_i = s->_matrix_ch[out_i][1 + j];
v += *(aIn + in_i + i * s->_in_ch_count) * matrix_coeff[out_i][in_i];
}
out[i * s->_out_ch_count] = aF(v);
}
break;
}
}
return 0;
}
|
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x17ae8
movq 0x68(%rsp), %rax
movl 0x48(%rsp), %ecx
leaq (%rax,%rcx,2), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rax
movl 0x48(%rsp), %ecx
movq %rcx, %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movzbl 0x4020(%rax,%rcx), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x17840
jmp 0x17823
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x1787e
jmp 0x1782e
movl 0x24(%rsp), %eax
subl $0x2, %eax
je 0x178f1
jmp 0x179da
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jae 0x17879
movq 0x40(%rsp), %rax
movl 0x3c(%rsp), %ecx
movq 0x70(%rsp), %rdx
imull 0x10(%rdx), %ecx
movl %ecx, %ecx
movw $0x0, (%rax,%rcx,2)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x17848
jmp 0x17ad6
movq 0x70(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x48(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x70(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x60(%rsp), %rdx
movslq 0x38(%rsp), %rax
shlq %rax
addq %rax, %rdx
movq 0x70(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %r8d
shlq $0x7, %r8
addq %r8, %rax
movslq 0x38(%rsp), %r8
movl (%rax,%r8,4), %r8d
movq 0x50(%rsp), %r9
movl 0x4c(%rsp), %eax
movl %eax, (%rsp)
callq 0x18a70
jmp 0x17ad6
movq 0x40(%rsp), %rdi
movq 0x70(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x60(%rsp), %rdx
movq 0x70(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x48(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %eax
cltq
shlq %rax
addq %rax, %rdx
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x48(%rsp), %r8d
imulq $0x21, %r8, %r8
addq %r8, %rax
movzbl 0x2(%rax), %eax
cltq
shlq %rax
addq %rax, %rcx
movq 0x70(%rsp), %rax
movl 0xc(%rax), %r8d
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %r9d
shlq $0x7, %r9
addq %r9, %rax
movq 0x70(%rsp), %r9
addq $0x4020, %r9 # imm = 0x4020
movl 0x48(%rsp), %r10d
imulq $0x21, %r10, %r10
addq %r10, %r9
movzbl 0x1(%r9), %r9d
movl (%rax,%r9,4), %r9d
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %r10d
shlq $0x7, %r10
addq %r10, %rax
movq 0x70(%rsp), %r10
addq $0x4020, %r10 # imm = 0x4020
movl 0x48(%rsp), %r11d
imulq $0x21, %r11, %r11
addq %r11, %r10
movzbl 0x2(%r10), %r10d
movl (%rax,%r10,4), %r11d
movq 0x50(%rsp), %r10
movl 0x4c(%rsp), %eax
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x18b10
jmp 0x17ad6
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jae 0x17ad4
movl $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x70(%rsp), %rcx
addq $0x4020, %rcx # imm = 0x4020
movl 0x48(%rsp), %edx
imulq $0x21, %rdx, %rdx
addq %rdx, %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jae 0x17a9b
movq 0x70(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x48(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movl 0x2c(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movl 0x28(%rsp), %ecx
shlq %rcx
addq %rcx, %rax
movl 0x34(%rsp), %ecx
movq 0x70(%rsp), %rdx
imull 0xc(%rdx), %ecx
movl %ecx, %ecx
movswl (%rax,%rcx,2), %eax
movq 0x58(%rsp), %rcx
movl 0x48(%rsp), %edx
shlq $0x7, %rdx
addq %rdx, %rcx
movl 0x28(%rsp), %edx
imull (%rcx,%rdx,4), %eax
addl 0x30(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x17a00
movq 0x50(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x18be0
movw %ax, %dx
movq 0x40(%rsp), %rax
movl 0x34(%rsp), %ecx
movq 0x70(%rsp), %rsi
imull 0x10(%rsi), %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x179e2
jmp 0x17ad6
jmp 0x17ad8
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x177da
xorl %eax, %eax
addq $0x78, %rsp
retq
nop
|
/kinetiknz[P]cubeb/src/cubeb_mixer.cpp
|
int rematrix<short, int, 32ul, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda0'(int)&>(MixerContext const*, short*, short const*, int const (&) [32ul][32ul], cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda0'(int)&, unsigned int)
|
static int
rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn,
const TYPE_COEFF (&matrix_coeff)[COLS][COLS], F && aF, uint32_t frames)
{
static_assert(
std::is_same<TYPE_COEFF, decltype(aF(matrix_coeff[0][0]))>::value,
"function must return the same type as used by matrix_coeff");
for (uint32_t out_i = 0; out_i < s->_out_ch_count; out_i++) {
TYPE * out = aOut + out_i;
switch (s->_matrix_ch[out_i][0]) {
case 0:
for (uint32_t i = 0; i < frames; i++) {
out[i * s->_out_ch_count] = 0;
}
break;
case 1: {
int in_i = s->_matrix_ch[out_i][1];
copy(out, s->_out_ch_count, aIn + in_i, s->_in_ch_count,
matrix_coeff[out_i][in_i], aF, frames);
} break;
case 2:
sum2(out, s->_out_ch_count, aIn + s->_matrix_ch[out_i][1],
aIn + s->_matrix_ch[out_i][2], s->_in_ch_count,
matrix_coeff[out_i][s->_matrix_ch[out_i][1]],
matrix_coeff[out_i][s->_matrix_ch[out_i][2]], aF, frames);
break;
default:
for (uint32_t i = 0; i < frames; i++) {
TYPE_COEFF v = 0;
for (uint32_t j = 0; j < s->_matrix_ch[out_i][0]; j++) {
uint32_t in_i = s->_matrix_ch[out_i][1 + j];
v += *(aIn + in_i + i * s->_in_ch_count) * matrix_coeff[out_i][in_i];
}
out[i * s->_out_ch_count] = aF(v);
}
break;
}
}
return 0;
}
|
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x17e28
movq 0x68(%rsp), %rax
movl 0x48(%rsp), %ecx
leaq (%rax,%rcx,2), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rax
movl 0x48(%rsp), %ecx
movq %rcx, %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movzbl 0x4020(%rax,%rcx), %eax
movl %eax, 0x24(%rsp)
testl %eax, %eax
je 0x17b80
jmp 0x17b63
movl 0x24(%rsp), %eax
subl $0x1, %eax
je 0x17bbe
jmp 0x17b6e
movl 0x24(%rsp), %eax
subl $0x2, %eax
je 0x17c31
jmp 0x17d1a
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jae 0x17bb9
movq 0x40(%rsp), %rax
movl 0x3c(%rsp), %ecx
movq 0x70(%rsp), %rdx
imull 0x10(%rdx), %ecx
movl %ecx, %ecx
movw $0x0, (%rax,%rcx,2)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x17b88
jmp 0x17e16
movq 0x70(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x48(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %eax
movl %eax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x70(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x60(%rsp), %rdx
movslq 0x38(%rsp), %rax
shlq %rax
addq %rax, %rdx
movq 0x70(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %r8d
shlq $0x7, %r8
addq %r8, %rax
movslq 0x38(%rsp), %r8
movl (%rax,%r8,4), %r8d
movq 0x50(%rsp), %r9
movl 0x4c(%rsp), %eax
movl %eax, (%rsp)
callq 0x18c30
jmp 0x17e16
movq 0x40(%rsp), %rdi
movq 0x70(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x60(%rsp), %rdx
movq 0x70(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x48(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movzbl 0x1(%rax), %eax
cltq
shlq %rax
addq %rax, %rdx
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x48(%rsp), %r8d
imulq $0x21, %r8, %r8
addq %r8, %rax
movzbl 0x2(%rax), %eax
cltq
shlq %rax
addq %rax, %rcx
movq 0x70(%rsp), %rax
movl 0xc(%rax), %r8d
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %r9d
shlq $0x7, %r9
addq %r9, %rax
movq 0x70(%rsp), %r9
addq $0x4020, %r9 # imm = 0x4020
movl 0x48(%rsp), %r10d
imulq $0x21, %r10, %r10
addq %r10, %r9
movzbl 0x1(%r9), %r9d
movl (%rax,%r9,4), %r9d
movq 0x58(%rsp), %rax
movl 0x48(%rsp), %r10d
shlq $0x7, %r10
addq %r10, %rax
movq 0x70(%rsp), %r10
addq $0x4020, %r10 # imm = 0x4020
movl 0x48(%rsp), %r11d
imulq $0x21, %r11, %r11
addq %r11, %r10
movzbl 0x2(%r10), %r10d
movl (%rax,%r10,4), %r11d
movq 0x50(%rsp), %r10
movl 0x4c(%rsp), %eax
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x18cd0
jmp 0x17e16
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jae 0x17e14
movl $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x70(%rsp), %rcx
addq $0x4020, %rcx # imm = 0x4020
movl 0x48(%rsp), %edx
imulq $0x21, %rdx, %rdx
addq %rdx, %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jae 0x17ddb
movq 0x70(%rsp), %rax
addq $0x4020, %rax # imm = 0x4020
movl 0x48(%rsp), %ecx
imulq $0x21, %rcx, %rcx
addq %rcx, %rax
movl 0x2c(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movl 0x28(%rsp), %ecx
shlq %rcx
addq %rcx, %rax
movl 0x34(%rsp), %ecx
movq 0x70(%rsp), %rdx
imull 0xc(%rdx), %ecx
movl %ecx, %ecx
movswl (%rax,%rcx,2), %eax
movq 0x58(%rsp), %rcx
movl 0x48(%rsp), %edx
shlq $0x7, %rdx
addq %rdx, %rcx
movl 0x28(%rsp), %edx
imull (%rcx,%rdx,4), %eax
addl 0x30(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x17d40
movq 0x50(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x18da0
movw %ax, %dx
movq 0x40(%rsp), %rax
movl 0x34(%rsp), %ecx
movq 0x70(%rsp), %rsi
imull 0x10(%rsi), %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x17d22
jmp 0x17e16
jmp 0x17e18
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x17b1a
xorl %eax, %eax
addq $0x78, %rsp
retq
nop
|
/kinetiknz[P]cubeb/src/cubeb_mixer.cpp
|
void sum2<float, float, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(float)&>(float*, unsigned int, float const*, float const*, unsigned int, float, float, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(float)&, unsigned int)
|
void
sum2(TYPE_SAMPLE * out, uint32_t stride_out, const TYPE_SAMPLE * in1,
const TYPE_SAMPLE * in2, uint32_t stride_in, TYPE_COEFF coeff1,
TYPE_COEFF coeff2, F && operand, uint32_t frames)
{
static_assert(
std::is_same<TYPE_COEFF, decltype(operand(coeff1))>::value,
"function must return the same type as used by coeff1 and coeff2");
for (uint32_t i = 0; i < frames; i++) {
*out = operand(coeff1 * *in1 + coeff2 * *in2);
out += stride_out;
in1 += stride_in;
in2 += stride_in;
}
}
|
subq $0x48, %rsp
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movss %xmm0, 0x20(%rsp)
movss %xmm1, 0x1c(%rsp)
movq %r9, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x50(%rsp), %eax
jae 0x18a45
movq 0x10(%rsp), %rdi
movss 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rax
movss (%rax), %xmm2
movss 0x1c(%rsp), %xmm1
movq 0x28(%rsp), %rax
mulss (%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x18a50
movq 0x40(%rsp), %rax
movss %xmm0, (%rax)
movl 0x3c(%rsp), %ecx
movq 0x40(%rsp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movl 0x24(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x189a9
addq $0x48, %rsp
retq
nopw (%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_mixer.cpp
|
cubeb_strings_init
|
int
cubeb_strings_init(cubeb_strings ** strings)
{
cubeb_strings * strs = NULL;
if (!strings) {
return CUBEB_ERROR;
}
strs = calloc(1, sizeof(cubeb_strings));
assert(strs);
if (!strs) {
return CUBEB_ERROR;
}
strs->size = sizeof(strs->small_store) / sizeof(strs->small_store[0]);
strs->count = 0;
strs->data = strs->small_store;
*strings = strs;
return CUBEB_OK;
}
|
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x18de3
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x18e40
movl $0x1, %edi
movl $0x30, %esi
callq 0x62e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x18e07
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x18e40
movq (%rsp), %rax
movl $0x4, (%rax)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rcx
addq $0x10, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
|
/kinetiknz[P]cubeb/src/cubeb_strings.c
|
cubeb_strings_lookup
|
static char const *
cubeb_strings_lookup(cubeb_strings * strings, char const * s)
{
char ** sp = NULL;
char ** se = NULL;
if (!strings || !s) {
return NULL;
}
sp = strings->data;
se = sp + strings->count;
for (; sp != se; sp++) {
if (*sp && strcmp(*sp, s) == 0) {
return *sp;
}
}
return NULL;
}
|
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x18fbf
cmpq $0x0, 0x10(%rsp)
jne 0x18fca
movq $0x0, 0x20(%rsp)
jmp 0x19047
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x1903e
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1902c
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x6810
cmpl $0x0, %eax
jne 0x1902c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x19047
jmp 0x1902e
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
jmp 0x18ff0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/src/cubeb_strings.c
|
testing::internal::BoolFromGTestEnv(char const*, bool)
|
bool BoolFromGTestEnv(const char* flag, bool default_value) {
const String env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
return string_value == NULL ?
default_value : strcmp(string_value, "0") != 0;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2b390
movq -0x48(%rbp), %rdi
callq 0x8200
movq %rax, -0x40(%rbp)
jmp 0x192a4
movq -0x40(%rbp), %rdi
callq 0x30990
movq %rax, -0x50(%rbp)
jmp 0x192b3
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x192ca
movb -0x9(%rbp), %al
movb %al, -0x51(%rbp)
jmp 0x192e3
movq -0x28(%rbp), %rdi
leaq 0x2c320(%rip), %rsi # 0x455f5
callq 0x6810
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
movb %al, -0x52(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8210
movb -0x52(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8210
movq -0x30(%rbp), %rdi
callq 0x6a40
nopl (%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest-port.cc
|
testing::internal::UnitTestOptions::GetOutputFormat()
|
String UnitTestOptions::GetOutputFormat() {
const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
if (gtest_output_flag == NULL) return String("");
const char* const colon = strchr(gtest_output_flag, ':');
return (colon == NULL) ?
String(gtest_output_flag) :
String(gtest_output_flag, colon - gtest_output_flag);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x4c932(%rip), %rdi # 0x66a50
callq 0x8200
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1a140
movq -0x28(%rbp), %rdi
leaq 0x3217a(%rip), %rsi # 0x4c2b3
callq 0x2d060
jmp 0x1a182
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x6170
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1a168
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2d060
jmp 0x1a180
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x2d260
jmp 0x1a182
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter()
|
ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
impl->SetGlobalTestPartResultReporter(old_reporter_);
} else {
impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x4a405(%rip), %rcx # 0x65420
movq %rcx, (%rax)
callq 0x2d4b0
movq %rax, -0x18(%rbp)
jmp 0x1b029
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x1b050
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x1af60
jmp 0x1b04e
jmp 0x1b065
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rsi
callq 0x1afd0
jmp 0x1b063
jmp 0x1b065
movq -0x20(%rbp), %rdi
callq 0x35b70
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2d4d0
nopl (%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::GetTimeInMillis()
|
TimeInMillis GetTimeInMillis() {
#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
// Difference between 1970-01-01 and 1601-01-01 in milliseconds.
// http://analogous.blogspot.com/2005/04/epoch.html
const TimeInMillis kJavaEpochToWinFileTimeDelta =
static_cast<TimeInMillis>(116444736UL) * 100000UL;
const DWORD kTenthMicrosInMilliSecond = 10000;
SYSTEMTIME now_systime;
FILETIME now_filetime;
ULARGE_INTEGER now_int64;
// TODO(kenton@google.com): Shouldn't this just use
// GetSystemTimeAsFileTime()?
GetSystemTime(&now_systime);
if (SystemTimeToFileTime(&now_systime, &now_filetime)) {
now_int64.LowPart = now_filetime.dwLowDateTime;
now_int64.HighPart = now_filetime.dwHighDateTime;
now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) -
kJavaEpochToWinFileTimeDelta;
return now_int64.QuadPart;
}
return 0;
#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_
__timeb64 now;
# ifdef _MSC_VER
// MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
// (deprecated function) there.
// TODO(kenton@google.com): Use GetTickCount()? Or use
// SystemTimeToFileTime()
# pragma warning(push) // Saves the current warning state.
# pragma warning(disable:4996) // Temporarily disables warning 4996.
_ftime64(&now);
# pragma warning(pop) // Restores the warning state.
# else
_ftime64(&now);
# endif // _MSC_VER
return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
#elif GTEST_HAS_GETTIMEOFDAY_
struct timeval now;
gettimeofday(&now, NULL);
return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000;
#else
# error "Don't know how to get the current time on your system."
#endif
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6970
imulq $0x3e8, -0x10(%rbp), %rax # imm = 0x3E8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)
|
String StringStreamToString(::std::stringstream* ss) {
const ::std::string& str = ss->str();
const char* const start = str.c_str();
const char* const end = start + str.length();
// We need to use a helper stringstream to do this transformation
// because String doesn't support push_back().
::std::stringstream helper;
for (const char* ch = start; ch != end; ++ch) {
if (*ch == '\0') {
helper << "\\0"; // Replaces NUL with "\\0";
} else {
helper.put(*ch);
}
}
return String(helper.str().c_str());
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x228(%rbp)
movq %rdi, %rax
movq %rax, -0x220(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x64c0
movq -0x218(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6190
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x210(%rbp)
movq -0x18(%rbp), %rdi
callq 0x68b0
movq %rax, %rcx
movq -0x210(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x6300
jmp 0x1ea13
movq -0x40(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x1eab6
movq -0x1e8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1ea83
leaq -0x1c0(%rbp), %rdi
leaq 0x25772(%rip), %rsi # 0x441be
callq 0x64d0
jmp 0x1ea53
jmp 0x1ea9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x1eb43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
jmp 0x1eb37
leaq -0x1c0(%rbp), %rdi
movq -0x1e8(%rbp), %rax
movsbl (%rax), %esi
callq 0x6050
jmp 0x1ea9b
jmp 0x1ea9d
jmp 0x1ea9f
movq -0x1e8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1e8(%rbp)
jmp 0x1ea1e
leaq -0x208(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x64c0
jmp 0x1eacb
leaq -0x208(%rbp), %rdi
callq 0x6190
movq -0x228(%rbp), %rdi
movq %rax, %rsi
callq 0x2d060
jmp 0x1eae8
leaq -0x208(%rbp), %rdi
callq 0x6290
leaq -0x1d0(%rbp), %rdi
callq 0x6340
leaq -0x38(%rbp), %rdi
callq 0x6290
movq -0x220(%rbp), %rax
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d8(%rbp)
movl %eax, -0x1dc(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x6290
leaq -0x1d0(%rbp), %rdi
callq 0x6340
leaq -0x38(%rbp), %rdi
callq 0x6290
movq -0x1d8(%rbp), %rdi
callq 0x6a40
nopl (%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*)
|
AssertionResult CmpHelperSTREQ(const char* expected_expression,
const char* actual_expression,
const wchar_t* expected,
const wchar_t* actual) {
if (String::WideCStringEquals(expected, actual)) {
return AssertionSuccess();
}
return EqFailure(expected_expression,
actual_expression,
String::ShowWideCStringQuoted(expected),
String::ShowWideCStringQuoted(actual),
false);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1ecb0
testb $0x1, %al
jne 0x1ed4d
jmp 0x1ed5b
movq -0x68(%rbp), %rdi
callq 0x1b6c0
jmp 0x1ede7
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1ec00
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1ec00
jmp 0x1ed87
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rcx
leaq -0x48(%rbp), %r8
xorl %r9d, %r9d
callq 0x1c330
jmp 0x1eda5
leaq -0x48(%rbp), %rdi
callq 0x8210
leaq -0x38(%rbp), %rdi
callq 0x8210
jmp 0x1ede7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1eddc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8210
leaq -0x38(%rbp), %rdi
callq 0x8210
jmp 0x1edf4
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6a40
nopl (%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*)
|
bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
const wchar_t* rhs) {
if (lhs == NULL) return rhs == NULL;
if (rhs == NULL) return false;
#if GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
return wcscasecmp(lhs, rhs) == 0;
#else
// Android, Mac OS X and Cygwin don't define wcscasecmp.
// Other unknown OSes may not define it either.
wint_t left, right;
do {
left = towlower(*lhs++);
right = towlower(*rhs++);
} while (left && left == right);
return left == right;
#endif // OS selector
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1eff6
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f01b
cmpq $0x0, -0x18(%rbp)
jne 0x1f003
movb $0x0, -0x1(%rbp)
jmp 0x1f01b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6af0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::String::EndsWithCaseInsensitive(char const*) const
|
bool String::EndsWithCaseInsensitive(const char* suffix) const {
if (suffix == NULL || CStringEquals(suffix, "")) return true;
if (c_str() == NULL) return false;
const size_t this_len = strlen(c_str());
const size_t suffix_len = strlen(suffix);
return (this_len >= suffix_len) &&
CaseInsensitiveCStringEquals(c_str() + this_len - suffix_len, suffix);
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1f2b5
movq -0x18(%rbp), %rdi
leaq 0x2d009(%rip), %rsi # 0x4c2b3
callq 0x1bf70
testb $0x1, %al
jne 0x1f2b5
jmp 0x1f2bb
movb $0x1, -0x1(%rbp)
jmp 0x1f32e
movq -0x30(%rbp), %rdi
callq 0x8200
cmpq $0x0, %rax
jne 0x1f2d0
movb $0x0, -0x1(%rbp)
jmp 0x1f32e
movq -0x30(%rbp), %rdi
callq 0x8200
movq %rax, %rdi
callq 0x61b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x61b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x31(%rbp)
jb 0x1f326
movq -0x30(%rbp), %rdi
callq 0x8200
movq %rax, %rdi
addq -0x20(%rbp), %rdi
xorl %eax, %eax
subq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1d5e0
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::TestResult::ValidateTestProperty(testing::TestProperty const&)
|
bool TestResult::ValidateTestProperty(const TestProperty& test_property) {
internal::String key(test_property.key());
if (key == "name" || key == "status" || key == "time" || key == "classname") {
ADD_FAILURE()
<< "Reserved key used in RecordProperty(): "
<< key
<< " ('name', 'status', 'time', and 'classname' are reserved by "
<< GTEST_NAME_ << ")";
return false;
}
return true;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ee80
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2d060
movq -0x50(%rbp), %rdi
leaq 0x2588a(%rip), %rsi # 0x44f1d
callq 0x2f010
movb %al, -0x45(%rbp)
jmp 0x1f69d
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x1f703
jmp 0x1f6a6
leaq 0x2c5a3(%rip), %rsi # 0x4bc50
leaq -0x20(%rbp), %rdi
callq 0x2f010
movb %al, -0x51(%rbp)
jmp 0x1f6bb
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x1f703
jmp 0x1f6c4
leaq 0x251e5(%rip), %rsi # 0x448b0
leaq -0x20(%rbp), %rdi
callq 0x2f010
movb %al, -0x52(%rbp)
jmp 0x1f6d9
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x1f703
jmp 0x1f6e2
leaq 0x2c56e(%rip), %rsi # 0x4bc57
leaq -0x20(%rbp), %rdi
callq 0x2f010
movb %al, -0x53(%rbp)
jmp 0x1f6f7
movb -0x53(%rbp), %al
testb $0x1, %al
jne 0x1f703
jmp 0x1f806
leaq -0x38(%rbp), %rdi
callq 0x80e0
jmp 0x1f70e
leaq 0x2c54c(%rip), %rsi # 0x4bc61
leaq -0x38(%rbp), %rdi
callq 0x2f090
movq %rax, -0x60(%rbp)
jmp 0x1f724
movq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9090
movq %rax, -0x68(%rbp)
jmp 0x1f737
movq -0x68(%rbp), %rdi
leaq 0x2c547(%rip), %rsi # 0x4bc89
callq 0x2f0f0
movq %rax, -0x70(%rbp)
jmp 0x1f74d
movq -0x70(%rbp), %rdi
leaq 0x2c56e(%rip), %rsi # 0x4bcc6
callq 0x8e60
movq %rax, -0x78(%rbp)
jmp 0x1f763
movq -0x78(%rbp), %rdi
leaq 0x2c970(%rip), %rsi # 0x4c0de
callq 0x2d550
movq %rax, -0x80(%rbp)
jmp 0x1f779
leaq 0x2c22b(%rip), %rdx # 0x4b9ab
leaq 0x2c54b(%rip), %r8 # 0x4bcd2
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
movl $0x72a, %ecx # imm = 0x72A
callq 0x197d0
jmp 0x1f79c
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x19890
jmp 0x1f7ab
leaq -0x40(%rbp), %rdi
callq 0x19850
leaq -0x38(%rbp), %rdi
callq 0x8160
movb $0x0, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
jmp 0x1f811
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1f828
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1f7fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x19850
leaq -0x38(%rbp), %rdi
callq 0x8160
jmp 0x1f828
movb $0x1, -0x1(%rbp)
movl $0x1, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8210
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x8210
movq -0x28(%rbp), %rdi
callq 0x6a40
nopw (%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type, testing::internal::String const&)
|
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
const String& message) {
// This function is a friend of UnitTest and as such has access to
// AddTestPartResult.
UnitTest::GetInstance()->AddTestPartResult(
result_type,
NULL, // No info about the source file where the exception occurred.
-1, // We have no info on which line caused the exception.
message,
String()); // No stack trace, either.
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x19980
movq %rax, -0x50(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2d170
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %r8
movq -0x38(%rbp), %r9
xorl %eax, %eax
movl %eax, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x19a10
jmp 0x1fc42
leaq -0x20(%rbp), %rdi
callq 0x8210
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8210
movq -0x28(%rbp), %rdi
callq 0x6a40
nop
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::Test::HasSameFixtureClass()
|
bool Test::HasSameFixtureClass() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
const TestCase* const test_case = impl->current_test_case();
// Info about the first test in the current test case.
const TestInfo* const first_test_info = test_case->test_info_list()[0];
const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
const char* const first_test_name = first_test_info->name();
// Info about the current test.
const TestInfo* const this_test_info = impl->current_test_info();
const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
const char* const this_test_name = this_test_info->name();
if (this_fixture_id != first_fixture_id) {
// Is the first test defined using TEST?
const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
// Is this test defined using TEST?
const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
if (first_is_TEST || this_is_TEST) {
// The user mixed TEST and TEST_F in this test case - we'll tell
// him/her how to fix it.
// Gets the name of the TEST and the name of the TEST_F. Note
// that first_is_TEST and this_is_TEST cannot both be true, as
// the fixture IDs are different for the two tests.
const char* const TEST_name =
first_is_TEST ? first_test_name : this_test_name;
const char* const TEST_F_name =
first_is_TEST ? this_test_name : first_test_name;
ADD_FAILURE()
<< "All tests in the same test case must use the same test fixture\n"
<< "class, so mixing TEST_F and TEST in the same test case is\n"
<< "illegal. In test case " << this_test_info->test_case_name()
<< ",\n"
<< "test " << TEST_F_name << " is defined using TEST_F but\n"
<< "test " << TEST_name << " is defined using TEST. You probably\n"
<< "want to change the TEST to TEST_F or move it to another test\n"
<< "case.";
} else {
// The user defined two fixture classes with the same name in
// two namespaces - we'll tell him/her how to fix it.
ADD_FAILURE()
<< "All tests in the same test case must use the same test fixture\n"
<< "class. However, in test case "
<< this_test_info->test_case_name() << ",\n"
<< "you defined test " << first_test_name
<< " and test " << this_test_name << "\n"
<< "using two different test fixture classes. This can happen if\n"
<< "the two classes are from different namespaces or translation\n"
<< "units and have the same name. You should probably rename one\n"
<< "of the classes to put the tests into different test cases.";
}
return false;
}
return true;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
callq 0x2d4b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f5f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2f610
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2f630
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2f650
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f670
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2f650
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x201e7
movq -0x28(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x1b110
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0x49(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x1b110
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, -0x4a(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x1fd54
testb $0x1, -0x4a(%rbp)
je 0x1ffbf
testb $0x1, -0x49(%rbp)
je 0x1fd67
movq -0x30(%rbp), %rax
movq %rax, -0xb8(%rbp)
jmp 0x1fd72
movq -0x48(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x58(%rbp)
testb $0x1, -0x49(%rbp)
je 0x1fd90
movq -0x48(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x1fd9b
movq -0x30(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x80e0
movq -0xd0(%rbp), %rdi
leaq 0x2bf15(%rip), %rsi # 0x4bcd9
callq 0x2f690
movq %rax, -0xc8(%rbp)
jmp 0x1fdd2
movq -0xc8(%rbp), %rdi
leaq 0x2bf39(%rip), %rsi # 0x4bd19
callq 0x2f6f0
movq %rax, -0xd8(%rbp)
jmp 0x1fdee
movq -0xd8(%rbp), %rdi
leaq 0x2bf58(%rip), %rsi # 0x4bd54
callq 0x2f750
movq %rax, -0xe0(%rbp)
jmp 0x1fe0a
movq -0x38(%rbp), %rdi
callq 0x2f7b0
movq %rax, -0xe8(%rbp)
jmp 0x1fe1c
movq -0xe0(%rbp), %rdi
movq -0xe8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x8f40
movq %rax, -0xf0(%rbp)
jmp 0x1fe40
movq -0xf0(%rbp), %rdi
leaq 0x2bd76(%rip), %rsi # 0x4bbc4
callq 0x2dcc0
movq %rax, -0xf8(%rbp)
jmp 0x1fe5c
movq -0xf8(%rbp), %rdi
leaq 0x2bfb6(%rip), %rsi # 0x4be20
callq 0x9000
movq %rax, -0x100(%rbp)
jmp 0x1fe78
movq -0x100(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8f40
movq %rax, -0x108(%rbp)
jmp 0x1fe91
movq -0x108(%rbp), %rdi
leaq 0x2becd(%rip), %rsi # 0x4bd6c
callq 0x2f7d0
movq %rax, -0x110(%rbp)
jmp 0x1fead
movq -0x110(%rbp), %rdi
leaq 0x2bf65(%rip), %rsi # 0x4be20
callq 0x9000
movq %rax, -0x118(%rbp)
jmp 0x1fec9
movq -0x118(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8f40
movq %rax, -0x120(%rbp)
jmp 0x1fee2
movq -0x120(%rbp), %rdi
leaq 0x2be9a(%rip), %rsi # 0x4bd8a
callq 0x2f830
movq %rax, -0x128(%rbp)
jmp 0x1fefe
movq -0x128(%rbp), %rdi
leaq 0x2bea5(%rip), %rsi # 0x4bdb1
callq 0x2f890
movq %rax, -0x130(%rbp)
jmp 0x1ff1a
movq -0x130(%rbp), %rdi
leaq 0x2bec7(%rip), %rsi # 0x4bdef
callq 0x9000
movq %rax, -0x138(%rbp)
jmp 0x1ff36
leaq 0x2ba6e(%rip), %rdx # 0x4b9ab
leaq 0x2bd8e(%rip), %r8 # 0x4bcd2
leaq -0x88(%rbp), %rdi
movl $0x1, %esi
movl $0x7bf, %ecx # imm = 0x7BF
callq 0x197d0
jmp 0x1ff5c
movq -0x138(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x19890
jmp 0x1ff71
leaq -0x88(%rbp), %rdi
callq 0x19850
leaq -0x68(%rbp), %rdi
callq 0x8160
jmp 0x201e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1ffb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x19850
leaq -0x68(%rbp), %rdi
callq 0x8160
jmp 0x201f9
leaq -0x90(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x80e0
movq -0x148(%rbp), %rdi
leaq 0x2bcf9(%rip), %rsi # 0x4bcd9
callq 0x2f690
movq %rax, -0x140(%rbp)
jmp 0x1ffee
movq -0x140(%rbp), %rdi
leaq 0x2bdf9(%rip), %rsi # 0x4bdf5
callq 0x2f8f0
movq %rax, -0x150(%rbp)
jmp 0x2000a
movq -0x38(%rbp), %rdi
callq 0x2f7b0
movq %rax, -0x158(%rbp)
jmp 0x2001c
movq -0x150(%rbp), %rdi
movq -0x158(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rsi
callq 0x8f40
movq %rax, -0x160(%rbp)
jmp 0x20046
movq -0x160(%rbp), %rdi
leaq 0x2bb70(%rip), %rsi # 0x4bbc4
callq 0x2dcc0
movq %rax, -0x168(%rbp)
jmp 0x20062
movq -0x168(%rbp), %rdi
leaq 0x2bda4(%rip), %rsi # 0x4be14
callq 0x2f950
movq %rax, -0x170(%rbp)
jmp 0x2007e
movq -0x170(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8f40
movq %rax, -0x178(%rbp)
jmp 0x20097
movq -0x178(%rbp), %rdi
leaq 0x2bd81(%rip), %rsi # 0x4be26
callq 0x2d4f0
movq %rax, -0x180(%rbp)
jmp 0x200b3
movq -0x180(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8f40
movq %rax, -0x188(%rbp)
jmp 0x200cc
movq -0x188(%rbp), %rdi
leaq 0x2c1d8(%rip), %rsi # 0x4c2b2
callq 0x2d550
movq %rax, -0x190(%rbp)
jmp 0x200e8
movq -0x190(%rbp), %rdi
leaq 0x2bd3b(%rip), %rsi # 0x4be31
callq 0x2f9b0
movq %rax, -0x198(%rbp)
jmp 0x20104
movq -0x198(%rbp), %rdi
leaq 0x2bd5e(%rip), %rsi # 0x4be70
callq 0x2f890
movq %rax, -0x1a0(%rbp)
jmp 0x20120
movq -0x1a0(%rbp), %rdi
leaq 0x2bd80(%rip), %rsi # 0x4beae
callq 0x2f9b0
movq %rax, -0x1a8(%rbp)
jmp 0x2013c
movq -0x1a8(%rbp), %rdi
leaq 0x2bda3(%rip), %rsi # 0x4beed
callq 0x2f6f0
movq %rax, -0x1b0(%rbp)
jmp 0x20158
leaq 0x2b84c(%rip), %rdx # 0x4b9ab
leaq 0x2bb6c(%rip), %r8 # 0x4bcd2
leaq -0xa0(%rbp), %rdi
movl $0x1, %esi
movl $0x7cb, %ecx # imm = 0x7CB
callq 0x197d0
jmp 0x2017e
movq -0x1b0(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x19890
jmp 0x20193
leaq -0xa0(%rbp), %rdi
callq 0x19850
leaq -0x90(%rbp), %rdi
callq 0x8160
jmp 0x201e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x201d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x19850
leaq -0x90(%rbp), %rdi
callq 0x8160
jmp 0x201f9
movb $0x0, -0x1(%rbp)
jmp 0x201eb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x6a40
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::UnitTestImpl::os_stack_trace_getter()
|
OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == NULL) {
os_stack_trace_getter_ = new OsStackTraceGetter;
}
return os_stack_trace_getter_;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x188(%rax)
jne 0x20371
movl $0x40, %edi
callq 0x64f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x33040
jmp 0x20349
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x188(%rax)
jmp 0x20371
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x6490
jmp 0x20382
movq -0x20(%rbp), %rax
movq 0x188(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x6a40
nopl (%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::TestInfo::TestInfo(char const*, char const*, char const*, char const*, void const*, testing::internal::TestFactoryBase*)
|
TestInfo::TestInfo(const char* a_test_case_name,
const char* a_name,
const char* a_type_param,
const char* a_value_param,
internal::TypeId fixture_class_id,
internal::TestFactoryBase* factory)
: test_case_name_(a_test_case_name),
name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : NULL),
value_param_(a_value_param ? new std::string(a_value_param) : NULL),
fixture_class_id_(fixture_class_id),
should_run_(false),
is_disabled_(false),
matches_filter_(false),
factory_(factory),
result_() {}
|
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x6a50
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x67d0
jmp 0x2042e
leaq -0x31(%rbp), %rdi
callq 0x6570
movq -0x88(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x45(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x6a50
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
callq 0x67d0
jmp 0x20480
leaq -0x45(%rbp), %rdi
callq 0x6570
movq -0x88(%rbp), %rax
addq $0x40, %rax
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, -0x51(%rbp)
movb $0x0, -0x53(%rbp)
cmpq $0x0, %rax
je 0x2051e
movl $0x20, %edi
callq 0x64f0
movq %rax, -0xb0(%rbp)
jmp 0x204c0
movq -0xb0(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x1, -0x51(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x52(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6a50
movq -0xb0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
movb $0x1, -0x53(%rbp)
callq 0x67d0
jmp 0x2050a
movq -0xb0(%rbp), %rax
movb $0x0, -0x51(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x20529
xorl %eax, %eax
movq %rax, -0xc8(%rbp)
jmp 0x20529
movq -0xa8(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x2fc50
jmp 0x2053e
testb $0x1, -0x53(%rbp)
jne 0x20546
jmp 0x2054f
leaq -0x52(%rbp), %rdi
callq 0x6570
movq -0x88(%rbp), %rax
addq $0x48, %rax
movq %rax, -0xd0(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, -0x61(%rbp)
movb $0x0, -0x63(%rbp)
cmpq $0x0, %rax
je 0x205e4
movl $0x20, %edi
callq 0x64f0
movq %rax, -0xd8(%rbp)
jmp 0x20586
movq -0xd8(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x1, -0x61(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x62(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x6a50
movq -0xd8(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
movb $0x1, -0x63(%rbp)
callq 0x67d0
jmp 0x205d0
movq -0xd8(%rbp), %rax
movb $0x0, -0x61(%rbp)
movq %rax, -0xf0(%rbp)
jmp 0x205ef
xorl %eax, %eax
movq %rax, -0xf0(%rbp)
jmp 0x205ef
movq -0xd0(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x2fc50
jmp 0x20604
testb $0x1, -0x63(%rbp)
jne 0x2060c
jmp 0x20615
leaq -0x62(%rbp), %rdi
callq 0x6570
movq -0x88(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, 0x50(%rdi)
movb $0x0, 0x58(%rdi)
movb $0x0, 0x59(%rdi)
movb $0x0, 0x5a(%rdi)
movq 0x10(%rbp), %rax
movq %rax, 0x60(%rdi)
addq $0x68, %rdi
callq 0x1f340
jmp 0x20643
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x6570
jmp 0x20738
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x6570
jmp 0x2072f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x20723
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x53(%rbp)
jne 0x206a5
jmp 0x206ae
leaq -0x52(%rbp), %rdi
callq 0x6570
testb $0x1, -0x51(%rbp)
jne 0x206b6
jmp 0x206bf
movq -0x50(%rbp), %rdi
callq 0x6490
jmp 0x20723
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x20717
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
testb $0x1, -0x63(%rbp)
jne 0x206e3
jmp 0x206ec
leaq -0x62(%rbp), %rdi
callq 0x6570
testb $0x1, -0x61(%rbp)
jne 0x206f4
jmp 0x206fd
movq -0x60(%rbp), %rdi
callq 0x6490
jmp 0x20717
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2fc70
movq -0xa8(%rbp), %rdi
callq 0x2fc70
movq -0xa0(%rbp), %rdi
callq 0x6290
movq -0x80(%rbp), %rdi
callq 0x6290
movq -0x40(%rbp), %rdi
callq 0x6a40
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::ReportInvalidTestCaseType(char const*, char const*, int)
|
void ReportInvalidTestCaseType(const char* test_case_name,
const char* file, int line) {
Message errors;
errors
<< "Attempted redefinition of test case " << test_case_name << ".\n"
<< "All tests in the same test case must use the same test fixture\n"
<< "class. However, in test case " << test_case_name << ", you tried\n"
<< "to define a test using a fixture class different from the one\n"
<< "used earlier. This can happen if the two fixture classes are\n"
<< "from different namespaces and have the same name. You should\n"
<< "probably rename one of the classes to put the tests into different\n"
<< "test cases.";
fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
errors.GetString().c_str());
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x80e0
movq -0x70(%rbp), %rdi
leaq 0x2b6ab(%rip), %rsi # 0x4bf49
callq 0x2fe00
movq %rax, -0x68(%rbp)
jmp 0x208a9
movq -0x68(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x8f40
movq %rax, -0x78(%rbp)
jmp 0x208bc
movq -0x78(%rbp), %rdi
leaq 0x2b926(%rip), %rsi # 0x4c1ed
callq 0x2dcc0
movq %rax, -0x80(%rbp)
jmp 0x208d2
movq -0x80(%rbp), %rdi
leaq 0x2b3fc(%rip), %rsi # 0x4bcd9
callq 0x2f690
movq %rax, -0x88(%rbp)
jmp 0x208eb
movq -0x88(%rbp), %rdi
leaq 0x2b4fc(%rip), %rsi # 0x4bdf5
callq 0x2f8f0
movq %rax, -0x90(%rbp)
jmp 0x20907
movq -0x90(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x8f40
movq %rax, -0x98(%rbp)
jmp 0x20920
movq -0x98(%rbp), %rdi
leaq 0x2b640(%rip), %rsi # 0x4bf6e
callq 0x2fe60
movq %rax, -0xa0(%rbp)
jmp 0x2093c
movq -0xa0(%rbp), %rdi
leaq 0x2b631(%rip), %rsi # 0x4bf7b
callq 0x2f9b0
movq %rax, -0xa8(%rbp)
jmp 0x20958
movq -0xa8(%rbp), %rdi
leaq 0x2b654(%rip), %rsi # 0x4bfba
callq 0x2f890
movq %rax, -0xb0(%rbp)
jmp 0x20974
movq -0xb0(%rbp), %rdi
leaq 0x2b676(%rip), %rsi # 0x4bff8
callq 0x2f890
movq %rax, -0xb8(%rbp)
jmp 0x20990
movq -0xb8(%rbp), %rdi
leaq 0x2b698(%rip), %rsi # 0x4c036
callq 0x2fec0
movq %rax, -0xc0(%rbp)
jmp 0x209ac
movq -0xc0(%rbp), %rdi
leaq 0x2b562(%rip), %rsi # 0x4bf1c
callq 0x8e60
jmp 0x209c1
movq 0x45600(%rip), %rax # 0x65fc8
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x50(%rbp), %rdi
callq 0x20ab0
jmp 0x209e4
leaq -0x50(%rbp), %rdi
callq 0x6190
movq %rax, -0xd0(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8ec0
jmp 0x20a03
leaq -0x60(%rbp), %rdi
callq 0x8200
movq %rax, -0xd8(%rbp)
jmp 0x20a15
movq -0xd8(%rbp), %rcx
movq -0xd0(%rbp), %rdx
movq -0xc8(%rbp), %rdi
leaq 0x2b649(%rip), %rsi # 0x4c07a
movb $0x0, %al
callq 0x6840
leaq -0x60(%rbp), %rdi
callq 0x8210
leaq -0x50(%rbp), %rdi
callq 0x6290
leaq -0x20(%rbp), %rdi
callq 0x8160
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20a96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20a8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8210
leaq -0x50(%rbp), %rdi
callq 0x6290
leaq -0x20(%rbp), %rdi
callq 0x8160
movq -0x28(%rbp), %rdi
callq 0x6a40
nopl (%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::FormatFileLocation[abi:cxx11](char const*, int)
|
GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
const char* const file_name = file == NULL ? kUnknownFile : file;
if (line < 0) {
return String::Format("%s:", file_name).c_str();
}
#ifdef _MSC_VER
return String::Format("%s(%d):", file_name, line).c_str();
#else
return String::Format("%s:%d:", file_name, line).c_str();
#endif // _MSC_VER
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x20ae5
leaq 0x2a09c(%rip), %rax # 0x4ab7b
movq %rax, -0x70(%rbp)
jmp 0x20aed
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x20b96
movq -0x20(%rbp), %rdx
leaq 0x2c2c7(%rip), %rsi # 0x4cdd1
xorl %eax, %eax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1aca0
movq -0x80(%rbp), %rdi
callq 0x8200
movq %rax, -0x78(%rbp)
jmp 0x20b28
leaq -0x3d(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6a50
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x67d0
jmp 0x20b4e
leaq -0x3d(%rbp), %rdi
callq 0x6570
leaq -0x30(%rbp), %rdi
callq 0x8210
jmp 0x20c36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x20b88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3d(%rbp), %rdi
callq 0x6570
leaq -0x30(%rbp), %rdi
callq 0x8210
jmp 0x20c43
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq 0x2c231(%rip), %rsi # 0x4cdd5
xorl %eax, %eax
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1aca0
movq -0x98(%rbp), %rdi
callq 0x8200
movq %rax, -0x90(%rbp)
jmp 0x20bcb
leaq -0x51(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6a50
movq -0x68(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0x67d0
jmp 0x20bf4
leaq -0x51(%rbp), %rdi
callq 0x6570
leaq -0x50(%rbp), %rdi
callq 0x8210
jmp 0x20c36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x20c2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x6570
leaq -0x50(%rbp), %rdi
callq 0x8210
jmp 0x20c43
movq -0x60(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6a40
nopl (%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest-port.cc
|
testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&)
|
void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
const char* const type_param = test_info.type_param();
const char* const value_param = test_info.value_param();
if (type_param != NULL || value_param != NULL) {
printf(", where ");
if (type_param != NULL) {
printf("TypeParam = %s", type_param);
if (value_param != NULL)
printf(" and ");
}
if (value_param != NULL) {
printf("GetParam() = %s", value_param);
}
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x309f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x217a4
cmpq $0x0, -0x18(%rbp)
je 0x217fd
leaq 0x2a982(%rip), %rdi # 0x4c12d
movb $0x0, %al
callq 0x6070
cmpq $0x0, -0x10(%rbp)
je 0x217e2
movq -0x10(%rbp), %rsi
leaq 0x2a972(%rip), %rdi # 0x4c136
movb $0x0, %al
callq 0x6070
cmpq $0x0, -0x18(%rbp)
je 0x217e0
leaq 0x2a3b7(%rip), %rdi # 0x4bb90
movb $0x0, %al
callq 0x6070
jmp 0x217e2
cmpq $0x0, -0x18(%rbp)
je 0x217fb
movq -0x18(%rbp), %rsi
leaq 0x2a951(%rip), %rdi # 0x4c145
movb $0x0, %al
callq 0x6070
jmp 0x217fd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(testing::TestResult const&)
|
String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlAttribute(property.value()) << "\"";
}
return attributes.GetString();
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x80e0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f4b0
movl %eax, %ecx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jge 0x2484d
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1f450
movq %rax, -0x70(%rbp)
jmp 0x2473c
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x28400(%rip), %rsi # 0x4cb4b
leaq -0x18(%rbp), %rdi
callq 0x2d550
movq %rax, -0x78(%rbp)
jmp 0x2475a
movq -0x28(%rbp), %rdi
callq 0x2ee80
movq %rax, -0x80(%rbp)
jmp 0x24769
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x8f40
movq %rax, -0x88(%rbp)
jmp 0x24787
movq -0x88(%rbp), %rdi
leaq 0x28bd8(%rip), %rsi # 0x4d36d
callq 0x2d550
movq %rax, -0x90(%rbp)
jmp 0x247a3
movq -0x90(%rbp), %rdi
leaq 0x28e8a(%rip), %rsi # 0x4d63b
callq 0x2d550
movq %rax, -0x98(%rbp)
jmp 0x247bf
movq -0x28(%rbp), %rdi
callq 0x2eff0
movq %rax, -0xa0(%rbp)
jmp 0x247d1
movq -0xa0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x31120
jmp 0x247e3
movq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9090
movq %rax, -0xa8(%rbp)
jmp 0x247fc
movq -0xa8(%rbp), %rdi
leaq 0x28e31(%rip), %rsi # 0x4d63b
callq 0x2d550
jmp 0x24811
leaq -0x50(%rbp), %rdi
callq 0x8210
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2470e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x24872
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8210
jmp 0x24872
movq -0x60(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8ec0
jmp 0x2485c
leaq -0x18(%rbp), %rdi
callq 0x8160
movq -0x58(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x8160
movq -0x30(%rbp), %rdi
callq 0x6a40
nopw %cs:(%rax,%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest.cc
|
bool testing::internal::ParseNaturalNumber<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*)
|
bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
// Fail fast if the given string does not begin with a digit;
// this bypasses strtoXXX's "optional leading whitespace and plus
// or minus sign" semantics, which are undesirable here.
if (str.empty() || !IsDigit(str[0])) {
return false;
}
errno = 0;
char* end;
// BiggestConvertible is the largest integer type that system-provided
// string-to-number conversion routines can return.
# if GTEST_OS_WINDOWS && !defined(__GNUC__)
// MSVC and C++ Builder define __int64 instead of the standard long long.
typedef unsigned __int64 BiggestConvertible;
const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
# else
typedef unsigned long long BiggestConvertible; // NOLINT
const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
# endif // GTEST_OS_WINDOWS && !defined(__GNUC__)
const bool parse_success = *end == '\0' && errno == 0;
// TODO(vladl@google.com): Convert this to compile time assertion when it is
// available.
GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
const Integer result = static_cast<Integer>(parsed);
if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
*number = result;
return true;
}
return false;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69e0
testb $0x1, %al
jne 0x347f6
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6590
movsbl (%rax), %edi
callq 0x42df0
testb $0x1, %al
jne 0x347ff
movb $0x0, -0x1(%rbp)
jmp 0x348e5
callq 0x6060
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6190
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
movl $0xa, %edx
callq 0x6770
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
jne 0x34847
callq 0x6060
cmpl $0x0, (%rax)
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movl $0x1, %edi
callq 0x197b0
testb $0x1, %al
jne 0x3485f
jmp 0x34861
jmp 0x348bb
leaq 0x18852(%rip), %rdx # 0x4d0ba
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x3, %esi
movl $0x3e9, %ecx # imm = 0x3E9
callq 0x2aef0
movq -0x50(%rbp), %rdi
callq 0x2d0c0
movq %rax, %rdi
leaq 0x18fc0(%rip), %rsi # 0x4d852
callq 0x64d0
jmp 0x34899
leaq -0x30(%rbp), %rdi
callq 0x2b030
jmp 0x348bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2b030
jmp 0x348f0
movq -0x28(%rbp), %rax
movl %eax, -0x40(%rbp)
testb $0x1, -0x29(%rbp)
je 0x348e1
movslq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x348e1
movl -0x40(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x348e5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6a40
nopl (%rax)
|
/kinetiknz[P]cubeb/googletest/src/gtest-internal-inl.h
|
QtMWidgets::BlurEffect::paintEvent(QPaintEvent*)
|
void
BlurEffect::paintEvent( QPaintEvent * )
{
QPainter p( this );
p.setRenderHint( QPainter::Antialiasing );
switch( policy )
{
case AbstractScrollArea::BlurAlwaysOff :
return;
case AbstractScrollArea::BlurHorizontalOnly :
{
if( orientation == Qt::Vertical )
drawBlur( &p, color );
}
break;
case AbstractScrollArea::BlurVerticalOnly :
{
if( orientation == Qt::Horizontal )
drawBlur( &p, color );
}
break;
case AbstractScrollArea::BlurBothDirections :
drawBlur( &p, color );
break;
default :
break;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x10, %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x98a80
movq -0x30(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x971e0
jmp 0xb4f5b
movq -0x38(%rbp), %rax
movl 0x28(%rax), %eax
movq %rax, -0x40(%rbp)
subq $0x3, %rax
ja 0xb5007
movq -0x40(%rbp), %rax
leaq 0x5a775(%rip), %rcx # 0x10f6f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x97b10
jmp 0xb501f
movl $0x1, -0x28(%rbp)
jmp 0xb5010
movq -0x38(%rbp), %rax
cmpl $0x2, 0x2c(%rax)
jne 0xb4fc9
movq -0x38(%rbp), %rdi
movq %rdi, %rdx
addq $0x30, %rdx
leaq -0x18(%rbp), %rsi
callq 0xb5030
jmp 0xb4fc7
jmp 0xb4fc9
jmp 0xb5009
movq -0x38(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0xb4fed
movq -0x38(%rbp), %rdi
movq %rdi, %rdx
addq $0x30, %rdx
leaq -0x18(%rbp), %rsi
callq 0xb5030
jmp 0xb4feb
jmp 0xb4fed
jmp 0xb5009
movq -0x38(%rbp), %rdi
movq %rdi, %rdx
addq $0x30, %rdx
leaq -0x18(%rbp), %rsi
callq 0xb5030
jmp 0xb5005
jmp 0xb5009
jmp 0xb5009
movl $0x0, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x97b10
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x97810
nopl (%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp
|
QtMWidgets::DateTimePicker::DateTimePicker(QVariant const&, QMetaType::Type, QWidget*)
|
DateTimePicker::DateTimePicker( const QVariant & val, QMetaType::Type parserType,
QWidget * parent )
: QWidget( parent )
, d( new DateTimePickerPrivate( this, parserType ) )
{
setSizePolicy( QSizePolicy( QSizePolicy::Fixed,
QSizePolicy::Fixed ) );
switch( val.metaType().id() )
{
case QMetaType::QDate :
setDate( val.toDate() );
break;
case QMetaType::QTime :
setTime( val.toTime() );
break;
case QMetaType::QDateTime :
setDateTime( val.toDateTime() );
break;
default :
setDateTime( QDateTime( DATETIMEPICKER_DATE_INITIAL,
DATETIMEPICKER_TIME_MIN ) );
}
connect( d->scroller, &Scroller::aboutToStart,
this, &DateTimePicker::_q_scrollAboutToStart );
connect( d->scroller, &Scroller::scroll,
this, &DateTimePicker::_q_scroll );
connect( d->scroller, &Scroller::finished,
this, &DateTimePicker::_q_scrollFinished );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x9a500
movq -0x108(%rbp), %rsi
movq -0x100(%rbp), %rdi
movl -0x24(%rbp), %edx
callq 0x97d10
movq -0x100(%rbp), %rax
leaq 0x7f37b(%rip), %rcx # 0x13e548
movq %rcx, %rdx
addq $0x10, %rdx
movq %rdx, (%rax)
addq $0x1c0, %rcx # imm = 0x1C0
movq %rcx, 0x10(%rax)
addq $0x28, %rax
movq %rax, -0xf8(%rbp)
movl $0xa8, %edi
callq 0x980d0
movq %rax, -0xf0(%rbp)
jmp 0xbf200
movq -0x100(%rbp), %rsi
movq -0xf0(%rbp), %rdi
movl -0x14(%rbp), %edx
callq 0xc1390
jmp 0xbf218
movq -0xf0(%rbp), %rsi
movq -0xf8(%rbp), %rdi
callq 0xc1630
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
movl $0x1, %ecx
movl %edx, %esi
callq 0xb18f0
movq -0x100(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x971f0
jmp 0xbf24e
movq -0x10(%rbp), %rdi
callq 0x981a0
movq %rax, -0x110(%rbp)
jmp 0xbf260
movq -0x110(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x9b7e0
movl %eax, -0x114(%rbp)
jmp 0xbf27e
movl -0x114(%rbp), %eax
subl $0xe, %eax
je 0xbf2f4
jmp 0xbf28b
movl -0x114(%rbp), %eax
subl $0xf, %eax
je 0xbf328
jmp 0xbf29c
movl -0x114(%rbp), %eax
subl $0x10, %eax
je 0xbf359
jmp 0xbf39f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xbf5b6
movq -0xf0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0xa8, %esi
callq 0x971b0
jmp 0xbf5b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xbf5aa
movq -0x10(%rbp), %rdi
callq 0x98420
movq %rax, -0x120(%rbp)
jmp 0xbf306
movq -0x100(%rbp), %rdi
movq -0x120(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0xbecd0
jmp 0xbf323
jmp 0xbf400
movq -0x10(%rbp), %rdi
callq 0x98d70
movl %eax, -0x124(%rbp)
jmp 0xbf339
movq -0x100(%rbp), %rdi
movl -0x124(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0xbf0a0
jmp 0xbf354
jmp 0xbf400
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x98b40
jmp 0xbf368
movq -0x100(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xbe920
jmp 0xbf37a
leaq -0x58(%rbp), %rdi
callq 0x97b70
jmp 0xbf400
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x97b70
jmp 0xbf5aa
leaq -0x68(%rbp), %rdi
movl $0x7d0, %esi # imm = 0x7D0
movl $0x1, %ecx
movl %ecx, %edx
callq 0x97ad0
jmp 0xbf3b6
leaq -0x6c(%rbp), %rdi
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x98130
jmp 0xbf3cd
movq -0x68(%rbp), %rsi
movl -0x6c(%rbp), %edx
leaq -0x60(%rbp), %rdi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x97cd0
jmp 0xbf3e5
movq -0x100(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xbe920
jmp 0xbf3f7
leaq -0x60(%rbp), %rdi
callq 0x97b70
movq -0x100(%rbp), %rdi
addq $0x28, %rdi
callq 0xc17a0
movq -0x100(%rbp), %r8
movq 0x98(%rax), %rsi
leaq -0x19d15(%rip), %rax # 0xa5710
movq %rax, -0x88(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
leaq -0xf36(%rip), %rax # 0xbe510
movq %rax, -0x98(%rbp)
movq $0x0, -0x90(%rbp)
movups -0x98(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x78(%rbp), %rdi
xorl %r9d, %r9d
callq 0xc1650
jmp 0xbf473
leaq -0x78(%rbp), %rdi
callq 0x977f0
movq -0x100(%rbp), %rdi
addq $0x28, %rdi
callq 0xc17a0
movq -0x100(%rbp), %r8
movq 0x98(%rax), %rsi
leaq -0x19de1(%rip), %rax # 0xa56c0
movq %rax, -0xb0(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0xb0(%rbp), %rdx
movq -0xa8(%rbp), %rcx
leaq -0xf88(%rip), %rax # 0xbe540
movq %rax, -0xc0(%rbp)
movq $0x0, -0xb8(%rbp)
movups -0xc0(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
xorl %r9d, %r9d
callq 0xc17c0
jmp 0xbf4f8
leaq -0xa0(%rbp), %rdi
callq 0x977f0
movq -0x100(%rbp), %rdi
addq $0x28, %rdi
callq 0xc17a0
movq -0x100(%rbp), %r8
movq 0x98(%rax), %rsi
leaq -0x19de9(%rip), %rax # 0xa5740
movq %rax, -0xd8(%rbp)
movq $0x0, -0xd0(%rbp)
movq -0xd8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
leaq -0xfd0(%rip), %rax # 0xbe580
movq %rax, -0xe8(%rbp)
movq $0x0, -0xe0(%rbp)
movups -0xe8(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0xc8(%rbp), %rdi
xorl %r9d, %r9d
callq 0xc1650
jmp 0xbf580
leaq -0xc8(%rbp), %rdi
callq 0x977f0
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x97b70
movq -0xf8(%rbp), %rdi
callq 0xc1910
movq -0x100(%rbp), %rdi
callq 0x976e0
movq -0x30(%rbp), %rdi
callq 0x97810
nopl (%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/datetimepicker.cpp
|
QtMWidgets::FingerGeometry::longTouchBounce()
|
int
FingerGeometry::longTouchBounce()
{
static const int bounce = qRound(
(qreal) qMax( FingerGeometry::height(), FingerGeometry::width() ) * 0.6 );
return bounce;
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpb $0x0, 0x80799(%rip) # 0x145798
jne 0xc5078
leaq 0x80790(%rip), %rdi # 0x145798
callq 0x982c0
cmpl $0x0, %eax
je 0xc5078
callq 0xc4e40
movl %eax, -0x1c(%rbp)
jmp 0xc501c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
callq 0xc4d50
movl %eax, -0x20(%rbp)
jmp 0xc502c
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x4(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb1d00
movq %rax, -0x28(%rbp)
jmp 0xc5045
movq -0x28(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd 0x4a83b(%rip), %xmm1 # 0x10f890
mulsd %xmm1, %xmm0
callq 0xb4280
movl %eax, -0x2c(%rbp)
jmp 0xc5063
movl -0x2c(%rbp), %eax
movl %eax, 0x80724(%rip) # 0x145790
leaq 0x80725(%rip), %rdi # 0x145798
callq 0x98570
movl 0x80712(%rip), %eax # 0x145790
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x80701(%rip), %rdi # 0x145798
callq 0x97530
movq -0x10(%rbp), %rdi
callq 0x97810
nopw %cs:(%rax,%rax)
nop
|
/igormironchik[P]qtmwidgets/src/fingergeometry.cpp
|
QtMWidgets::TableViewCellLayout::sizeHint() const
|
QSize
TableViewCellLayout::sizeHint() const
{
const QSize imageSize = imageLabel->sizeHint();
int width = imageSize.width();
int height = imageSize.height();
const QSize textSize = textLabel->sizeHint();
const QSize detailedTextSize = detailedTextLabel->sizeHint();
width += qMax( textSize.width(), detailedTextSize.width() );
height = qMax( height,
textSize.height() + detailedTextSize.height() );
const QSize accessorySize = accessoryWidget->sizeHint();
width += accessorySize.width();
height = qMax( height, accessorySize.height() );
return QSize( width + contentsMargins().left() + contentsMargins().right(),
height + contentsMargins().top() + contentsMargins().bottom() );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb9860
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb9870
movl %eax, %ecx
movq -0xa0(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb9860
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb9860
movl %eax, -0x38(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb1d00
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb9870
movl %eax, -0xac(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb9870
movl %eax, %ecx
movl -0xac(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xb1d00
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x20(%rbp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, -0x44(%rbp)
leaq -0x44(%rbp), %rdi
callq 0xb9860
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x44(%rbp), %rdi
callq 0xb9870
movl %eax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xb1d00
movq -0xa0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xa8(%rbp)
callq 0x98b00
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xba2b0
movq -0xa0(%rbp), %rdi
movl %eax, %ecx
movl -0xa8(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xa4(%rbp)
callq 0x98b00
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xba2e0
movq -0xa0(%rbp), %rdi
movl %eax, %ecx
movl -0xa4(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x8c(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x94(%rbp)
callq 0x98b00
movq %rax, -0x78(%rbp)
movq %rdx, -0x70(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xba2c0
movq -0xa0(%rbp), %rdi
movl %eax, %ecx
movl -0x94(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x90(%rbp)
callq 0x98b00
movq %rax, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xba300
movl -0x90(%rbp), %edx
movl -0x8c(%rbp), %esi
addl %eax, %edx
leaq -0x8(%rbp), %rdi
callq 0xa0c80
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/tableview.cpp
|
QtMWidgets::MsgBoxTitlePrivate::init()
|
void
MsgBoxTitlePrivate::init()
{
q->setBackgroundRole( QPalette::Window );
q->setAutoFillBackground( true );
q->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
q->setMinimumHeight( qMax( FingerGeometry::height(),
q->fontMetrics().height() + q->fontMetrics().height() / 3 ) );
prepareTitle();
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rdi
movl $0xa, %esi
callq 0x98360
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x98160
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0x7, %esi
xorl %edx, %edx
callq 0xb97b0
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
callq 0xc4e40
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq (%rax), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xba230
movq -0x40(%rbp), %rdi
callq 0x98d10
movl %eax, -0x34(%rbp)
jmp 0xd08ec
movq -0x48(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0xba230
jmp 0xd08fe
leaq -0x30(%rbp), %rdi
callq 0x98d10
movl %eax, -0x54(%rbp)
jmp 0xd090c
movl -0x34(%rbp), %eax
movl -0x54(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x55555556, %rcx, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xb1d00
movq %rax, -0x60(%rbp)
jmp 0xd0941
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rax
movl (%rax), %esi
callq 0x98c60
jmp 0xd0952
leaq -0x30(%rbp), %rdi
callq 0x97900
leaq -0x18(%rbp), %rdi
callq 0x97900
movq -0x48(%rbp), %rdi
callq 0xd09b0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xd0996
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x97900
leaq -0x18(%rbp), %rdi
callq 0x97900
movq -0x20(%rbp), %rdi
callq 0x97810
nopl (%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/messagebox.cpp
|
QtMWidgets::MessageBoxPrivate::init(QString const&, QString const&)
|
void
MessageBoxPrivate::init( const QString & titl, const QString & txt )
{
q->setModal( true );
QVBoxLayout * layout = new QVBoxLayout( q );
layout->setContentsMargins( 0, 0, 0, 0 );
frame = new QFrame( q );
frame->setFrameStyle( QFrame::Box | QFrame::Plain );
layout->addWidget( frame );
vbox = new QVBoxLayout( frame );
vbox->setSpacing( 0 );
vbox->setContentsMargins( 3, 3, 3, 3 );
title = new MsgBoxTitle( titl, frame );
vbox->addWidget( title );
h1 = new QFrame( frame );
h1->setFrameStyle( QFrame::HLine | QFrame::Sunken );
vbox->addWidget( h1 );
scrollArea = new ScrollArea( frame );
scrollArea->setWidgetResizable( true );
textLabel = new TextLabel( frame );
textLabel->setBackgroundRole( QPalette::Window );
textLabel->setColor( q->palette().color( QPalette::WindowText ) );
textLabel->setAutoFillBackground( true );
textLabel->setText( txt );
scrollArea->setWidget( textLabel );
vbox->addWidget( scrollArea );
h2 = new QFrame( frame );
h2->setFrameStyle( QFrame::HLine | QFrame::Sunken );
vbox->addWidget( h2 );
hbox = new QHBoxLayout;
hbox->setSpacing( 0 );
hbox->setContentsMargins( 0, 0, 0, 0 );
okButton = new MsgBoxButton( QObject::tr( "OK" ), frame );
buttonsMap.insert( okButton, MessageBox::AcceptRole );
buttons.append( okButton );
hbox->addWidget( okButton );
vbox->addLayout( hbox );
q->resize( vbox->sizeHint() );
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq (%rax), %rdi
movl $0x1, %esi
callq 0x97820
movl $0x20, %edi
callq 0x980d0
movq %rax, %rdi
movq -0xa8(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0xa0(%rbp)
movq (%rax), %rsi
callq 0x97c50
jmp 0xd0c67
movq -0xa0(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %r8d, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x97f20
movl $0x28, %edi
callq 0x980d0
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0xb8(%rbp)
movq %rcx, -0xc0(%rbp)
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9a500
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movl -0x30(%rbp), %edx
callq 0x97d70
jmp 0xd0cd4
movq -0xa8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movl $0x11, %esi
callq 0x98c20
movq -0xa8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0xd8(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0xd0(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x9a520
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movl -0x34(%rbp), %ecx
xorl %edx, %edx
callq 0x98140
movl $0x20, %edi
callq 0x980d0
movq %rax, %rdi
movq -0xa8(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0xc8(%rbp)
movq 0x10(%rax), %rsi
callq 0x97c50
jmp 0xd0d5b
movq -0xa8(%rbp), %rax
movq -0xc8(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
movq (%rdi), %rax
movq 0x68(%rax), %rax
xorl %esi, %esi
callq *%rax
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x3, %r8d
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x97f20
movl $0x30, %edi
callq 0x980d0
movq %rax, %rdi
movq -0xa8(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0xe0(%rbp)
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rdx
callq 0xd2750
jmp 0xd0dc8
movq -0xa8(%rbp), %rax
movq -0xe0(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq 0x18(%rax), %rcx
movq %rcx, -0x108(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9a520
movq -0x108(%rbp), %rdi
movq -0x100(%rbp), %rsi
movl -0x38(%rbp), %ecx
xorl %edx, %edx
callq 0x98140
movl $0x28, %edi
callq 0x980d0
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0xe8(%rbp)
leaq -0x3c(%rbp), %rdi
callq 0x9a500
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x97d70
jmp 0xd0e5f
movq -0xa8(%rbp), %rax
movq -0xf8(%rbp), %rcx
movq %rcx, 0x90(%rax)
movq 0x90(%rax), %rdi
movl $0x34, %esi
callq 0x98c20
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x120(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x118(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9a520
movq -0x120(%rbp), %rdi
movq -0x118(%rbp), %rsi
movl -0x40(%rbp), %ecx
xorl %edx, %edx
callq 0x98140
movl $0x30, %edi
callq 0x980d0
movq %rax, %rdi
movq -0xa8(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x110(%rbp)
movq 0x10(%rax), %rsi
callq 0xfe530
jmp 0xd0eef
movq -0xa8(%rbp), %rax
movq -0x110(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rdi
movl $0x1, %esi
callq 0xfead0
movl $0x30, %edi
callq 0x980d0
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x130(%rbp)
movq %rcx, -0x138(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x128(%rbp)
leaq -0x44(%rbp), %rdi
callq 0x9a500
movq -0x130(%rbp), %rdi
movq -0x128(%rbp), %rsi
movl -0x44(%rbp), %edx
callq 0xc60a0
jmp 0xd0f5d
movq -0xa8(%rbp), %rax
movq -0x138(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq 0x38(%rax), %rdi
movl $0xa, %esi
callq 0x98360
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
movq 0x38(%rax), %rax
movq %rax, -0x170(%rbp)
callq 0x97f10
movq %rax, %rdi
xorl %esi, %esi
movl %esi, -0x154(%rbp)
callq 0xb18c0
movq -0x170(%rbp), %rdi
movq %rax, %rsi
callq 0xc66a0
movq -0xa8(%rbp), %rax
movq 0x38(%rax), %rdi
movl $0x1, %esi
callq 0x98160
movq -0xa8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xc62a0
movq -0xa8(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0xfe780
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x168(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x160(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9a520
movq -0x168(%rbp), %rdi
movq -0x160(%rbp), %rsi
movl -0x154(%rbp), %edx
movl -0x48(%rbp), %ecx
callq 0x98140
movl $0x28, %edi
callq 0x980d0
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x148(%rbp)
movq %rcx, -0x150(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x140(%rbp)
leaq -0x4c(%rbp), %rdi
callq 0x9a500
movq -0x148(%rbp), %rdi
movq -0x140(%rbp), %rsi
movl -0x4c(%rbp), %edx
callq 0x97d70
jmp 0xd1083
movq -0xa8(%rbp), %rax
movq -0x150(%rbp), %rcx
movq %rcx, 0x98(%rax)
movq 0x98(%rax), %rdi
movl $0x34, %esi
callq 0x98c20
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x188(%rbp)
movq 0x98(%rax), %rax
movq %rax, -0x180(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9a520
movq -0x188(%rbp), %rdi
movq -0x180(%rbp), %rsi
movl -0x50(%rbp), %ecx
xorl %edx, %edx
callq 0x98140
movl $0x20, %edi
callq 0x980d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x178(%rbp)
callq 0x98240
jmp 0xd1108
movq -0xa8(%rbp), %rax
movq -0x178(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rdi
movq (%rdi), %rax
movq 0x68(%rax), %rax
xorl %esi, %esi
movl %esi, -0x194(%rbp)
callq *%rax
movq -0xa8(%rbp), %rax
movl -0x194(%rbp), %r8d
movq 0x20(%rax), %rdi
movl %r8d, %esi
movl %r8d, %edx
movl %r8d, %ecx
callq 0x97f20
movl $0x30, %edi
callq 0x980d0
movq %rax, %rcx
movl -0x194(%rbp), %eax
movq %rcx, -0x190(%rbp)
movb $0x1, -0x69(%rbp)
leaq 0x3e880(%rip), %rsi # 0x10f9f4
movl %eax, %edx
leaq -0x68(%rbp), %rdi
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0xd2860
jmp 0xd1186
movq -0x190(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq 0x10(%rax), %rdx
leaq -0x68(%rbp), %rsi
callq 0x107620
jmp 0xd11a3
movq -0xa8(%rbp), %rax
movq -0x190(%rbp), %rcx
movb $0x0, -0x69(%rbp)
movq %rcx, 0x40(%rax)
leaq -0x68(%rbp), %rdi
callq 0xa7b90
movq -0xa8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x40(%rax), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x7c(%rbp)
leaq -0x78(%rbp), %rsi
leaq -0x7c(%rbp), %rdx
callq 0xd28a0
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x88(%rbp)
movq %rax, %rdi
addq $0x68, %rdi
movq 0x40(%rax), %rsi
callq 0xd2920
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x1b0(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x1a8(%rbp)
leaq -0x8c(%rbp), %rdi
callq 0x9a520
movq -0x1b0(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
movl -0x8c(%rbp), %ecx
xorl %edx, %edx
callq 0x98140
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
xorl %edx, %edx
callq 0x98260
movq -0xa8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x1a0(%rbp)
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0xf0(%rax)
movq -0x1a0(%rbp), %rdi
movq %rax, -0x94(%rbp)
leaq -0x94(%rbp), %rsi
callq 0x98c80
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbp
retq
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x20, %esi
callq 0x971b0
jmp 0xd140f
movq -0xc0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0x971b0
jmp 0xd140f
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x20, %esi
callq 0x971b0
jmp 0xd140f
movq -0xe0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x971b0
jmp 0xd140f
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0x971b0
jmp 0xd140f
movq -0x110(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x971b0
jmp 0xd140f
movq -0x138(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x971b0
jmp 0xd140f
movq -0x150(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x28, %esi
callq 0x971b0
jmp 0xd140f
movq -0x178(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x20, %esi
callq 0x971b0
jmp 0xd140f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xd13f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa7b90
testb $0x1, -0x69(%rbp)
jne 0xd13fc
jmp 0xd140d
movq -0x190(%rbp), %rdi
movl $0x30, %esi
callq 0x971b0
jmp 0xd140f
movq -0x28(%rbp), %rdi
callq 0x97810
nopl (%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/messagebox.cpp
|
QtMWidgets::ToolBar::_q_rightArrowClicked()
|
void
ToolBar::_q_rightArrowClicked()
{
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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
addq $0x28, %rdi
callq 0xebc90
movq 0x10(%rax), %rdi
callq 0xe8f60
cmpl $0x1, %eax
jne 0xeab21
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xebc90
movq %rax, %rdi
addq $0x8, %rdi
callq 0xb9860
movq -0x18(%rbp), %rdi
movl %eax, -0x1c(%rbp)
addq $0x28, %rdi
callq 0xebc90
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
jmp 0xeab5e
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xebc90
movq %rax, %rdi
addq $0x8, %rdi
callq 0xb9870
movq -0x18(%rbp), %rdi
movl %eax, -0x20(%rbp)
addq $0x28, %rdi
callq 0xebc90
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movl %eax, %ecx
movl -0x20(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xebc90
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0xe90f0
movq -0x18(%rbp), %rdi
callq 0x974f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/toolbar.cpp
|
QtMWidgets::SwitchPrivate::drawText(QPainter*, QStyleOption const&, QColor const&, QColor const&)
|
void
SwitchPrivate::drawText( QPainter * p, const QStyleOption & opt,
const QColor & on, const QColor & off )
{
const QRect r( radius, 0, opt.rect.width() - radius * 2, radius * 2 );
switch( state )
{
case Switch::NotAcceptedCheck :
case Switch::AcceptedCheck :
{
if( !onText.isEmpty() )
{
p->setPen( on );
p->drawText( r,
Qt::AlignLeft | Qt::TextSingleLine | Qt::AlignVCenter,
onText );
}
}
break;
case Switch::NotAcceptedUncheck :
case Switch::AcceptedUncheck :
{
if( !offText.isEmpty() )
{
p->setPen( off );
p->drawText( r,
Qt::AlignRight | Qt::TextSingleLine | Qt::AlignVCenter,
offText );
}
}
break;
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl 0x50(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xb1a10
movl -0x54(%rbp), %esi
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl 0x50(%rax), %r8d
addl %r8d, %r8d
subl %r8d, %ecx
leaq -0x38(%rbp), %rdi
xorl %edx, %edx
callq 0xb1e60
movq -0x50(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
subl $0x2, %eax
jb 0xedbfc
jmp 0xedb86
movl -0x44(%rbp), %eax
addl $-0x2, %eax
subl $0x1, %eax
ja 0xedc61
jmp 0xedb97
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0xc7530
testb $0x1, %al
jne 0xedbfa
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x98820
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x1, %edi
movl $0x100, %esi # imm = 0x100
callq 0xc12c0
movl %eax, -0x3c(%rbp)
leaq -0x3c(%rbp), %rdi
callq 0xc12f0
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %rdi
movl %eax, %edx
orl $0x80, %edx
addq $0x10, %rcx
leaq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
callq 0x982a0
jmp 0xedc61
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
callq 0xc7530
testb $0x1, %al
jne 0xedc5f
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x98820
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x2, %edi
movl $0x100, %esi # imm = 0x100
callq 0xc12c0
movl %eax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc12f0
movq -0x50(%rbp), %rcx
movq -0x68(%rbp), %rdi
movl %eax, %edx
orl $0x80, %edx
addq $0x28, %rcx
leaq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r8d
callq 0x982a0
jmp 0xedc61
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/switch.cpp
|
QtMWidgets::Switch::mouseMoveEvent(QMouseEvent*)
|
void
Switch::mouseMoveEvent( QMouseEvent * event )
{
if( d->leftMouseButtonPressed )
{
const int delta = event->pos().x() - d->mousePos.x();
d->offset += delta;
d->mouseMoveDelta += qAbs( delta );
d->mousePos = event->pos();
if( d->offset < 0 )
d->offset = 0;
else if( d->offset > rect().width() - d->radius * 2 - 2 )
d->offset = rect().width() - d->radius * 2 - 2;
update();
}
event->accept();
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x28, %rdi
callq 0xef3d0
testb $0x1, 0x60(%rax)
je 0xef2a2
movq -0x10(%rbp), %rdi
callq 0xb4490
movq %rax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xb2350
movq -0x50(%rbp), %rdi
movl %eax, -0x5c(%rbp)
addq $0x28, %rdi
callq 0xef3d0
movq %rax, %rdi
addq $0x64, %rdi
callq 0xb2350
movq -0x50(%rbp), %rdi
movl %eax, %ecx
movl -0x5c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x58(%rbp)
addq $0x28, %rdi
callq 0xef3d0
movl -0x58(%rbp), %ecx
addl 0x58(%rax), %ecx
movl %ecx, 0x58(%rax)
leaq -0x14(%rbp), %rdi
callq 0xb19e0
movq -0x50(%rbp), %rdi
movl %eax, -0x54(%rbp)
addq $0x28, %rdi
callq 0xef3d0
movl -0x54(%rbp), %ecx
addl 0x5c(%rax), %ecx
movl %ecx, 0x5c(%rax)
movq -0x10(%rbp), %rdi
callq 0xb4490
movq -0x50(%rbp), %rdi
movq %rax, -0x24(%rbp)
addq $0x28, %rdi
callq 0xef3d0
movq -0x50(%rbp), %rdi
movq -0x24(%rbp), %rcx
movq %rcx, 0x64(%rax)
addq $0x28, %rdi
callq 0xef3d0
cmpl $0x0, 0x58(%rax)
jge 0xef1f3
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
callq 0xef3d0
movl $0x0, 0x58(%rax)
jmp 0xef299
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
callq 0xef3d0
movq -0x50(%rbp), %rdi
movl 0x58(%rax), %eax
movl %eax, -0x60(%rbp)
callq 0xb1a50
movq %rax, -0x34(%rbp)
movq %rdx, -0x2c(%rbp)
leaq -0x34(%rbp), %rdi
callq 0xb1a10
movq -0x50(%rbp), %rdi
movl %eax, -0x64(%rbp)
addq $0x28, %rdi
callq 0xef3d0
movl -0x64(%rbp), %ecx
movq %rax, %rdx
movl -0x60(%rbp), %eax
movl 0x50(%rdx), %edx
shll %edx
subl %edx, %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jle 0xef297
movq -0x50(%rbp), %rdi
callq 0xb1a50
movq %rax, -0x44(%rbp)
movq %rdx, -0x3c(%rbp)
leaq -0x44(%rbp), %rdi
callq 0xb1a10
movq -0x50(%rbp), %rdi
movl %eax, -0x6c(%rbp)
addq $0x28, %rdi
callq 0xef3d0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl -0x6c(%rbp), %eax
movl 0x50(%rcx), %ecx
shll %ecx
subl %ecx, %eax
subl $0x2, %eax
movl %eax, -0x68(%rbp)
addq $0x28, %rdi
callq 0xef3d0
movl -0x68(%rbp), %ecx
movl %ecx, 0x58(%rax)
jmp 0xef299
movq -0x50(%rbp), %rdi
callq 0x974f0
movq -0x10(%rbp), %rdi
callq 0xb44d0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/switch.cpp
|
QtMWidgets::Picker::setModel(QAbstractItemModel*)
|
void
Picker::setModel( QAbstractItemModel * model )
{
if( !model )
{
qWarning( "QtMWidgets::Picker::setModel: cannot set a 0 model" );
return;
}
if( d->model )
{
disconnect( d->model, &QAbstractItemModel::dataChanged,
this, &Picker::_q_dataChanged );
disconnect( d->model, &QAbstractItemModel::rowsAboutToBeInserted,
this, &Picker::_q_updateIndexBeforeChange );
disconnect( d->model, &QAbstractItemModel::rowsInserted,
this, &Picker::_q_rowsInserted );
disconnect( d->model, &QAbstractItemModel::rowsAboutToBeRemoved,
this, &Picker::_q_updateIndexBeforeChange );
disconnect( d->model, &QAbstractItemModel::rowsRemoved,
this, &Picker::_q_rowsRemoved );
disconnect( d->model, &QAbstractItemModel::destroyed,
this, &Picker::_q_modelDestroyed );
disconnect( d->model, &QAbstractItemModel::modelAboutToBeReset,
this, &Picker::_q_updateIndexBeforeChange );
disconnect( d->model, &QAbstractItemModel::modelReset,
this, &Picker::_q_modelReset );
if( d->model->QObject::parent() == this )
delete d->model;
}
d->model = model;
connect( model, &QAbstractItemModel::dataChanged,
this, &Picker::_q_dataChanged );
connect( model, &QAbstractItemModel::rowsAboutToBeInserted,
this, &Picker::_q_updateIndexBeforeChange );
connect( model, &QAbstractItemModel::rowsInserted,
this, &Picker::_q_rowsInserted );
connect( model, &QAbstractItemModel::rowsAboutToBeRemoved,
this, &Picker::_q_updateIndexBeforeChange );
connect( model, &QAbstractItemModel::rowsRemoved,
this, &Picker::_q_rowsRemoved );
connect( model, &QAbstractItemModel::destroyed,
this, &Picker::_q_modelDestroyed );
connect( model, &QAbstractItemModel::modelAboutToBeReset,
this, &Picker::_q_updateIndexBeforeChange );
connect( model, &QAbstractItemModel::modelReset,
this, &Picker::_q_modelReset );
bool currentReset = false;
if( count() )
{
for( int pos = 0; pos < count(); ++pos )
{
if( d->model->index( pos, d->modelColumn, d->root ).flags() & Qt::ItemIsEnabled )
{
d->topItemIndex = d->model->index( pos, d->modelColumn, d->root );
setCurrentIndex( pos );
currentReset = true;
break;
}
}
}
if( !currentReset )
{
setCurrentIndex( -1 );
d->topItemIndex = QModelIndex();
}
}
|
pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp # imm = 0x3A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x300(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xef6fe
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
xorl %edx, %edx
movq %rcx, %rsi
callq 0x9aa30
leaq -0x30(%rbp), %rdi
leaq 0x20461(%rip), %rsi # 0x10fb53
movb $0x0, %al
callq 0x97400
jmp 0xf00fa
movq -0x300(%rbp), %rdi
addq $0x28, %rdi
callq 0xf45f0
cmpq $0x0, 0x8(%rax)
je 0xefa9c
movq -0x300(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x308(%rbp)
callq 0xf45f0
movq -0x300(%rbp), %rcx
movq 0x8(%rax), %rdi
movq 0x538ae(%rip), %rax # 0x142ff0
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0x2523(%rip), %rax # 0xf1c80
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x50(%rbp), %r8
movq -0x48(%rbp), %r9
callq 0xf48e0
movq -0x308(%rbp), %rdi
callq 0xf45f0
movq -0x300(%rbp), %rcx
movq 0x8(%rax), %rdi
movq 0x53824(%rip), %rax # 0x142fb8
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq 0x26f1(%rip), %rax # 0xf1ea0
movq %rax, -0x310(%rbp)
movq %rax, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x70(%rbp), %r8
movq -0x68(%rbp), %r9
callq 0xf4960
movq -0x308(%rbp), %rdi
callq 0xf45f0
movq -0x300(%rbp), %rcx
movq 0x8(%rax), %rdi
movq 0x53793(%rip), %rax # 0x142f80
movq %rax, -0x80(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq 0x26e8(%rip), %rax # 0xf1ef0
movq %rax, -0x90(%rbp)
movq $0x0, -0x88(%rbp)
movq -0x90(%rbp), %r8
movq -0x88(%rbp), %r9
callq 0xf49e0
movq -0x308(%rbp), %rdi
callq 0xf45f0
movq -0x300(%rbp), %rcx
movq %rax, %rdx
movq -0x310(%rbp), %rax
movq 0x8(%rdx), %rdi
movq 0x536d3(%rip), %rdx # 0x142f28
movq %rdx, -0xa0(%rbp)
movq $0x0, -0x98(%rbp)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rax, -0xb0(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0xb0(%rbp), %r8
movq -0xa8(%rbp), %r9
callq 0xf4960
movq -0x308(%rbp), %rdi
callq 0xf45f0
movq -0x300(%rbp), %rcx
movq 0x8(%rax), %rdi
movq 0x53610(%rip), %rax # 0x142ec8
movq %rax, -0xc0(%rbp)
movq $0x0, -0xb8(%rbp)
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq 0x2851(%rip), %rax # 0xf2130
movq %rax, -0xd0(%rbp)
movq $0x0, -0xc8(%rbp)
movq -0xd0(%rbp), %r8
movq -0xc8(%rbp), %r9
callq 0xf49e0
movq -0x308(%rbp), %rdi
callq 0xf45f0
movq -0x300(%rbp), %rcx
movq 0x8(%rax), %rdi
movq 0x535e6(%rip), %rax # 0x142f08
movq %rax, -0xe0(%rbp)
movq $0x0, -0xd8(%rbp)
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq 0x1f87(%rip), %rax # 0xf18d0
movq %rax, -0xf0(%rbp)
movq $0x0, -0xe8(%rbp)
movq -0xf0(%rbp), %r8
movq -0xe8(%rbp), %r9
callq 0xf4790
movq -0x308(%rbp), %rdi
callq 0xf45f0
movq -0x300(%rbp), %rcx
movq %rax, %rdx
movq -0x310(%rbp), %rax
movq 0x8(%rdx), %rdi
movq 0x5364a(%rip), %rdx # 0x142fe0
movq %rdx, -0x100(%rbp)
movq $0x0, -0xf8(%rbp)
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
movq %rax, -0x110(%rbp)
movq $0x0, -0x108(%rbp)
movq -0x110(%rbp), %r8
movq -0x108(%rbp), %r9
callq 0xf4a60
movq -0x308(%rbp), %rdi
callq 0xf45f0
movq -0x300(%rbp), %rcx
movq 0x8(%rax), %rdi
movq 0x53507(%rip), %rax # 0x142f00
movq %rax, -0x120(%rbp)
movq $0x0, -0x118(%rbp)
movq -0x120(%rbp), %rsi
movq -0x118(%rbp), %rdx
leaq 0x2970(%rip), %rax # 0xf2390
movq %rax, -0x130(%rbp)
movq $0x0, -0x128(%rbp)
movq -0x130(%rbp), %r8
movq -0x128(%rbp), %r9
callq 0xf4a60
movq -0x300(%rbp), %rdi
addq $0x28, %rdi
callq 0xf45f0
movq 0x8(%rax), %rdi
callq 0xb9990
movq -0x300(%rbp), %rcx
cmpq %rcx, %rax
jne 0xefa9a
movq -0x300(%rbp), %rdi
addq $0x28, %rdi
callq 0xf45f0
movq 0x8(%rax), %rax
movq %rax, -0x318(%rbp)
cmpq $0x0, %rax
je 0xefa98
movq -0x318(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0xefa9a
jmp 0xefa9c
movq -0x300(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x368(%rbp)
addq $0x28, %rdi
callq 0xf45f0
movq -0x368(%rbp), %rcx
movq -0x300(%rbp), %r8
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rsi
movq 0x5351c(%rip), %rax # 0x142ff0
movq %rax, -0x148(%rbp)
movq $0x0, -0x140(%rbp)
movq -0x148(%rbp), %rdx
movq -0x140(%rbp), %rcx
leaq 0x2185(%rip), %rax # 0xf1c80
movq %rax, -0x158(%rbp)
movq $0x0, -0x150(%rbp)
movups -0x158(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x138(%rbp), %rdi
movq %rdi, -0x360(%rbp)
xorl %r9d, %r9d
movl %r9d, -0x324(%rbp)
callq 0xf4ae0
movq -0x360(%rbp), %rdi
callq 0x977f0
movl -0x324(%rbp), %r9d
movq -0x300(%rbp), %r8
movq -0x10(%rbp), %rsi
movq 0x5345c(%rip), %rax # 0x142fb8
movq %rax, -0x170(%rbp)
movq $0x0, -0x168(%rbp)
movq -0x170(%rbp), %rdx
movq -0x168(%rbp), %rcx
leaq 0x231d(%rip), %rax # 0xf1ea0
movq %rax, -0x330(%rbp)
movq %rax, -0x180(%rbp)
movq $0x0, -0x178(%rbp)
movups -0x180(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x160(%rbp), %rdi
movq %rdi, -0x358(%rbp)
callq 0xf4c30
movq -0x358(%rbp), %rdi
callq 0x977f0
movl -0x324(%rbp), %r9d
movq -0x300(%rbp), %r8
movq -0x10(%rbp), %rsi
movq 0x5339f(%rip), %rax # 0x142f80
movq %rax, -0x198(%rbp)
movq $0x0, -0x190(%rbp)
movq -0x198(%rbp), %rdx
movq -0x190(%rbp), %rcx
leaq 0x22e8(%rip), %rax # 0xf1ef0
movq %rax, -0x1a8(%rbp)
movq $0x0, -0x1a0(%rbp)
movups -0x1a8(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x350(%rbp)
callq 0xf4d80
movq -0x350(%rbp), %rdi
callq 0x977f0
movq -0x330(%rbp), %rax
movl -0x324(%rbp), %r9d
movq -0x300(%rbp), %r8
movq -0x10(%rbp), %rsi
movq 0x532c2(%rip), %rcx # 0x142f28
movq %rcx, -0x1c0(%rbp)
movq $0x0, -0x1b8(%rbp)
movq -0x1c0(%rbp), %rdx
movq -0x1b8(%rbp), %rcx
movq %rax, -0x1d0(%rbp)
movq $0x0, -0x1c8(%rbp)
movups -0x1d0(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x348(%rbp)
callq 0xf4c30
movq -0x348(%rbp), %rdi
callq 0x977f0
movl -0x324(%rbp), %r9d
movq -0x300(%rbp), %r8
movq -0x10(%rbp), %rsi
movq 0x531eb(%rip), %rax # 0x142ec8
movq %rax, -0x1e8(%rbp)
movq $0x0, -0x1e0(%rbp)
movq -0x1e8(%rbp), %rdx
movq -0x1e0(%rbp), %rcx
leaq 0x242c(%rip), %rax # 0xf2130
movq %rax, -0x1f8(%rbp)
movq $0x0, -0x1f0(%rbp)
movups -0x1f8(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x340(%rbp)
callq 0xf4d80
movq -0x340(%rbp), %rdi
callq 0x977f0
movl -0x324(%rbp), %r9d
movq -0x300(%rbp), %r8
movq -0x10(%rbp), %rsi
movq 0x531ad(%rip), %rax # 0x142f08
movq %rax, -0x210(%rbp)
movq $0x0, -0x208(%rbp)
movq -0x210(%rbp), %rdx
movq -0x208(%rbp), %rcx
leaq 0x1b4e(%rip), %rax # 0xf18d0
movq %rax, -0x220(%rbp)
movq $0x0, -0x218(%rbp)
movups -0x220(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x200(%rbp), %rdi
movq %rdi, -0x338(%rbp)
callq 0xf4ed0
movq -0x338(%rbp), %rdi
callq 0x977f0
movq -0x330(%rbp), %rax
movl -0x324(%rbp), %r9d
movq -0x300(%rbp), %r8
movq -0x10(%rbp), %rsi
movq 0x53200(%rip), %rcx # 0x142fe0
movq %rcx, -0x238(%rbp)
movq $0x0, -0x230(%rbp)
movq -0x238(%rbp), %rdx
movq -0x230(%rbp), %rcx
movq %rax, -0x248(%rbp)
movq $0x0, -0x240(%rbp)
movups -0x248(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq -0x228(%rbp), %rdi
movq %rdi, -0x320(%rbp)
callq 0xf5020
movq -0x320(%rbp), %rdi
callq 0x977f0
movq -0x300(%rbp), %r8
movq -0x10(%rbp), %rsi
movq 0x530b0(%rip), %rax # 0x142f00
movq %rax, -0x260(%rbp)
movq $0x0, -0x258(%rbp)
movq -0x260(%rbp), %rdx
movq -0x258(%rbp), %rcx
leaq 0x2519(%rip), %rax # 0xf2390
movq %rax, -0x270(%rbp)
movq $0x0, -0x268(%rbp)
leaq -0x250(%rbp), %rdi
leaq -0x270(%rbp), %rax
xorl %r9d, %r9d
movq (%rax), %r10
movq %r10, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0xf5020
leaq -0x250(%rbp), %rdi
callq 0x977f0
movq -0x300(%rbp), %rdi
movb $0x0, -0x271(%rbp)
callq 0xf0820
cmpl $0x0, %eax
je 0xf00b1
movl $0x0, -0x278(%rbp)
movq -0x300(%rbp), %rdi
movl -0x278(%rbp), %eax
movl %eax, -0x36c(%rbp)
callq 0xf0820
movl %eax, %ecx
movl -0x36c(%rbp), %eax
cmpl %ecx, %eax
jge 0xf00af
movq -0x300(%rbp), %rdi
addq $0x28, %rdi
callq 0xf45f0
movq -0x300(%rbp), %rdi
movq 0x8(%rax), %rax
movq %rax, -0x380(%rbp)
movl -0x278(%rbp), %eax
movl %eax, -0x374(%rbp)
addq $0x28, %rdi
callq 0xf45f0
movq -0x300(%rbp), %rdi
movl 0x10(%rax), %eax
movl %eax, -0x370(%rbp)
addq $0x28, %rdi
callq 0xf45f0
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x2b0(%rbp), %rdi
callq 0x98440
movq -0x380(%rbp), %rsi
movl -0x374(%rbp), %edx
movl -0x370(%rbp), %ecx
movq (%rsi), %rax
leaq -0x298(%rbp), %rdi
leaq -0x2b0(%rbp), %r8
callq *0x60(%rax)
leaq -0x298(%rbp), %rdi
callq 0xf43c0
movl %eax, -0x280(%rbp)
leaq -0x280(%rbp), %rdi
movl $0x20, %esi
callq 0xf4410
movl %eax, -0x27c(%rbp)
leaq -0x27c(%rbp), %rdi
callq 0xf4450
cmpl $0x0, %eax
je 0xf0099
movq -0x300(%rbp), %rdi
addq $0x28, %rdi
callq 0xf45f0
movq -0x300(%rbp), %rdi
movq 0x8(%rax), %rax
movq %rax, -0x390(%rbp)
movl -0x278(%rbp), %eax
movl %eax, -0x388(%rbp)
addq $0x28, %rdi
callq 0xf45f0
movq -0x300(%rbp), %rdi
movl 0x10(%rax), %eax
movl %eax, -0x384(%rbp)
addq $0x28, %rdi
callq 0xf45f0
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x2e0(%rbp), %rdi
callq 0x98440
movq -0x390(%rbp), %rsi
movl -0x388(%rbp), %edx
movl -0x384(%rbp), %ecx
movq (%rsi), %rax
leaq -0x2c8(%rbp), %rdi
leaq -0x2e0(%rbp), %r8
callq *0x60(%rax)
movq -0x300(%rbp), %rdi
addq $0x28, %rdi
callq 0xf45f0
movq %rax, %rdi
addq $0x28, %rdi
leaq -0x2c8(%rbp), %rsi
callq 0x978d0
movq -0x300(%rbp), %rdi
movl -0x278(%rbp), %esi
callq 0xf2410
movb $0x1, -0x271(%rbp)
jmp 0xf00af
jmp 0xf009b
movl -0x278(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x278(%rbp)
jmp 0xefee1
jmp 0xf00b1
testb $0x1, -0x271(%rbp)
jne 0xf00fa
movq -0x300(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xf2410
leaq -0x2f8(%rbp), %rdi
callq 0xad3c0
movq -0x300(%rbp), %rdi
addq $0x28, %rdi
callq 0xf45f0
movq %rax, %rdi
addq $0x28, %rdi
leaq -0x2f8(%rbp), %rsi
callq 0x978d0
addq $0x3a0, %rsp # imm = 0x3A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/igormironchik[P]qtmwidgets/src/picker.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.