name string | code string | asm string | file string |
|---|---|---|---|
glfwGetCursorPos | GLFWAPI void glfwGetCursorPos(GLFWwindow* handle, double* xpos, double* ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
_GLFW_REQUIRE_INIT();
if (window->cursorMode == GLFW_CURSOR_DISABLED)
{
if... | testq %rdi, %rdi
je 0x18dfe
testq %rsi, %rsi
je 0x18da8
movq $0x0, (%rsi)
testq %rdx, %rdx
je 0x18db4
movq $0x0, (%rdx)
leaq 0x3aafd(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x18df0
cmpl $0x34003, 0x74(%rdi) # imm = 0x34003
jne 0x23c83
testq %rsi, %rsi
je 0x18dde
movsd 0x1e0(%rdi), %xmm0
movsd %xmm0, (%rsi)
te... | /anael-seghezzi[P]glfw/src/input.c |
glfwDestroyCursor | GLFWAPI void glfwDestroyCursor(GLFWcursor* handle)
{
_GLFWcursor* cursor = (_GLFWcursor*) handle;
_GLFW_REQUIRE_INIT();
if (cursor == NULL)
return;
// Make sure the cursor is not being used by any window
{
_GLFWwindow* window;
for (window = _glfw.windowListHead; window; ... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x3a8f7(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x19023
movq %rdi, %rbx
testq %rdi, %rdi
je 0x19038
movq 0x3f0(%rax), %r14
testq %r14, %r14
je 0x18fef
cmpq %rbx, 0x48(%r14)
jne 0x18fea
movq %r14, %rdi
xorl %esi, %esi
callq 0x190d2
movq (%r14), %r14
jmp 0x18fd5
movq %rbx, %rd... | /anael-seghezzi[P]glfw/src/input.c |
glfwCreateStandardCursor | GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape)
{
_GLFWcursor* cursor;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (shape != GLFW_ARROW_CURSOR &&
shape != GLFW_IBEAM_CURSOR &&
shape != GLFW_CROSSHAIR_CURSOR &&
shape != GLFW_HAND_CURSOR &&
shape != GLFW_HRESIZE_CURSOR &&
... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x3a86c(%rip), %r15 # 0x538b8
cmpl $0x0, (%r15)
je 0x1907b
movl %edi, %r14d
leal -0x36007(%r14), %eax
cmpl $-0x7, %eax
ja 0x1908d
leaq 0x2da16(%rip), %rsi # 0x46a7e
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %r14d, %edx
xorl %eax, %eax
callq 0x17e31
j... | /anael-seghezzi[P]glfw/src/input.c |
glfwSetCursor | GLFWAPI void glfwSetCursor(GLFWwindow* windowHandle, GLFWcursor* cursorHandle)
{
_GLFWwindow* window = (_GLFWwindow*) windowHandle;
_GLFWcursor* cursor = (_GLFWcursor*) cursorHandle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
window->cursor = cursor;
_glfwPlatformSetCursor(window, cursor);... | testq %rdi, %rdi
je 0x190fa
leaq 0x3a7da(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x190ec
movq %rsi, 0x48(%rdi)
jmp 0x24111
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x17e31
pushq %rax
leaq 0x1206d(%rip), %rdi # 0x2b16f
leaq 0x2d71b(%rip), %rsi # 0x46824
leaq 0x2d98d... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetJoystickAxes | GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputEr... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x194e3
cmpl $0x10, %edi
jae 0x19502
movq %rsi, %rbx
testq %rsi, %rsi
je 0x19521
movl $0x0, (%rbx)
leaq 0x3a434(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x194c8
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x194c4
... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetJoystickButtons | char* glfwGetJoystickButtons(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INV... | pushq %r15
pushq %r14
pushq %rbx
testl %edi, %edi
js 0x195dc
cmpl $0x10, %edi
jae 0x195fb
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1961a
movl $0x0, (%rbx)
leaq 0x3a349(%rip), %r15 # 0x538b8
cmpl $0x0, (%r15)
je 0x195c3
movl %edi, %eax
imulq $0x1fa0, %rax, %rax # imm = 0x1FA0
cmpl $0x0, 0x408(%r15,%rax)
je 0x195bf
... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetJoystickHats | char* glfwGetJoystickHats(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALI... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x196c6
cmpl $0x10, %edi
jae 0x196e5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x19704
movl $0x0, (%rbx)
leaq 0x3a251(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x196ab
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x196a7
... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetJoystickGUID | GLFWAPI const char* glfwGetJoystickGUID(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x1983f
cmpl $0x10, %edi
jae 0x1985e
leaq 0x3a0d3(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x19820
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x19832
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetJoystickUserPointer | GLFWAPI void* glfwGetJoystickUserPointer(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
js = _glfw.joysticks + jid;
if (!js->present)
return NULL;
return js->userPointer;
} | pushq %rbx
testl %edi, %edi
js 0x19953
cmpl $0x10, %edi
jae 0x19972
leaq 0x39fa5(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1993a
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x1994c
addq %rcx, %rax
addq $0x408, %rax # imm = 0x408
movq 0x40(%rax), %rbx
jmp... | /anael-seghezzi[P]glfw/src/input.c |
glfwJoystickIsGamepad | GLFWAPI int glfwJoystickIsGamepad(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x1a343
cmpl $0x10, %edi
jae 0x1a362
leaq 0x395d2(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1a325
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x1a337
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetGamepadName | GLFWAPI const char* glfwGetGamepadName(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x1a3ed
cmpl $0x10, %edi
jae 0x1a40c
leaq 0x39523(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1a3ce
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x408(%rax,%rcx)
je 0x1a3e0
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x... | /anael-seghezzi[P]glfw/src/input.c |
glfwGetGamepadState | GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state)
{
int i;
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(state != NULL);
memset(state, 0, sizeof(GLFWgamepadstate));
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (jid < 0 ||... | pushq %r15
pushq %r14
pushq %rbx
testl %edi, %edi
js 0x1a639
cmpl $0x10, %edi
jae 0x1a658
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a677
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x39452(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1a61f
movl %edi, %ecx
imulq $0x1fa0, ... | /anael-seghezzi[P]glfw/src/input.c |
glfwInputMonitor | void _glfwInputMonitor(_GLFWmonitor* monitor, int action, int placement)
{
if (action == GLFW_CONNECTED)
{
_glfw.monitorCount++;
_glfw.monitors =
realloc(_glfw.monitors, sizeof(_GLFWmonitor*) * _glfw.monitorCount);
if (placement == _GLFW_INSERT_FIRST)
{
m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x40001, %esi # imm = 0x40001
je 0x1a9c1
cmpl $0x40002, %ebp # imm = 0x40002
jne 0x1aa56
leaq 0x38fb2(%rip), %rax # 0x538b8
movq 0x3f0(%rax), %r14
testq %r14, %r14
je 0x1a981
le... | /anael-seghezzi[P]glfw/src/monitor.c |
glfwChooseVideoMode | const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
const GLFWvidmode* desired)
{
int i;
unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
unsigned int rateDiff, leastRateDiff = UINT_MAX;
unsigned int colorDiff, leastColorDiff = UINT_MAX;
const GLFWv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1acb0
testl %eax, %eax
je 0x1ac9f
movslq 0x28(%r14), %rcx
testq %rcx, %rcx
jle 0x1ac9f
movq 0x20(%r14), %rdx
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edi
movl 0x10(%rbx), %r8d
movl (%rbx), %eax
movl %eax, 0... | /anael-seghezzi[P]glfw/src/monitor.c |
refreshVideoModes | static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
{
int modeCount;
GLFWvidmode* modes;
if (monitor->modes)
return GLFW_TRUE;
modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
if (!modes)
return GLFW_FALSE;
qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x1, %ebx
cmpq $0x0, 0x20(%rdi)
jne 0x1ad0c
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
callq 0x1fec5
testq %rax, %rax
je 0x1ad0a
movq %rax, %r15
movslq 0xc(%rsp), %rsi
leaq 0x34(%rip), %rcx # 0x1ad1a
movl $0x18, %edx
movq %rax, %rdi
callq 0x13620
movq 0x20(%r14),... | /anael-seghezzi[P]glfw/src/monitor.c |
glfwSplitBPP | void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
{
int delta;
// We assume that by 32 the user really meant 24
if (bpp == 32)
bpp = 24;
// Convert "bits per pixel" to red, green & blue sizes
*red = *green = *blue = bpp / 3;
delta = bpp - (*red * 3);
if (delta >= 1)
... | cmpl $0x20, %edi
movl $0x18, %eax
cmovnel %edi, %eax
cltq
imulq $0x55555556, %rax, %rdi # imm = 0x55555556
movq %rdi, %r8
shrq $0x3f, %r8
shrq $0x20, %rdi
addl %r8d, %edi
movl %edi, (%rcx)
movl %edi, (%rdx)
movl %edi, (%rsi)
leal (%rdi,%rdi,2), %ecx
subl %ecx, %eax
testl %eax, %eax
jle 0x1ad81
incl (%rdx)
cmpl $0x2, %e... | /anael-seghezzi[P]glfw/src/monitor.c |
glfwGetVideoModes | GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = m... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b0a0
movq %rsi, %r14
testq %rsi, %rsi
je 0x1b0bf
movl $0x0, (%r14)
leaq 0x38854(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1b081
movq %rdi, %rbx
callq 0x1acb0
testl %eax, %eax
je 0x1b093
movl 0x28(%rbx), %eax
movl %eax, (%r14)
movq 0x20(%rbx), %rbx
jmp 0x1b0... | /anael-seghezzi[P]glfw/src/monitor.c |
glfwSetGamma | GLFWAPI void glfwSetGamma(GLFWmonitor* handle, float gamma)
{
unsigned int i;
unsigned short* values;
GLFWgammaramp ramp;
const GLFWgammaramp* original;
assert(handle != NULL);
assert(gamma > 0.f);
assert(gamma <= FLT_MAX);
_GLFW_REQUIRE_INIT();
if (gamma != gamma || gamma <= 0.f |... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
testq %rdi, %rdi
je 0x1b28d
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x1b2ac
movss 0x2bf18(%rip), %xmm1 # 0x47074
ucomiss %xmm0, %xmm1
jb 0x1b2cb
leaq 0x3874c(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1b19e
ucomiss 0x2befc(%rip), %xmm0... | /anael-seghezzi[P]glfw/src/monitor.c |
glfwSetGammaRamp | GLFWAPI void glfwSetGammaRamp(GLFWmonitor* handle, const GLFWgammaramp* ramp)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(ramp != NULL);
assert(ramp->size > 0);
assert(ramp->red != NULL);
assert(ramp->green != NULL);
assert(ramp->blue != NULL);
if (... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b3f4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1b413
cmpl $0x0, 0x18(%rbx)
je 0x1b432
cmpq $0x0, (%rbx)
je 0x1b451
cmpq $0x0, 0x8(%rbx)
je 0x1b470
cmpq $0x0, 0x10(%rbx)
je 0x1b48f
leaq 0x38511(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1b3d7
movq %rdi, %r14
cmpl... | /anael-seghezzi[P]glfw/src/monitor.c |
glfwGetInstanceProcAddress | GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance,
const char* procname)
{
GLFWvkproc proc;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
return NULL;
proc = (GLFWvkpr... | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x1b927
leaq 0x37ff3(%rip), %r15 # 0x538b8
cmpl $0x0, (%r15)
je 0x1b908
movq %rsi, %rbx
movq %rdi, %r14
movl $0x2, %edi
callq 0x1b4b0
testl %eax, %eax
je 0x1b91b
movq %r14, %rdi
movq %rbx, %rsi
callq *0x1fe98(%r15)
movq %rax, %r14
testq %rax, %rax
jne 0x1b91e
mov... | /anael-seghezzi[P]glfw/src/vulkan.c |
glfwInputWindowFocus | void _glfwInputWindowFocus(_GLFWwindow* window, GLFWbool focused)
{
if (window->callbacks.focus)
window->callbacks.focus((GLFWwindow*) window, focused);
if (!focused)
{
int key, button;
for (key = 0; key <= GLFW_KEY_LAST; key++)
{
if (window->keys[key] == GLFW... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x2d8(%rdi), %rax
testq %rax, %rax
je 0x1bb58
movq %rbx, %rdi
movl %ebp, %esi
callq *%rax
testl %ebp, %ebp
jne 0x1bbb3
xorl %r14d, %r14d
cmpb $0x1, 0x80(%rbx,%r14)
jne 0x1bb84
movl %r14d, %edi
callq 0x24063
movq %rbx, %rdi
movl %r14d, %esi
movl %eax,... | /anael-seghezzi[P]glfw/src/window.c |
glfwGetFramebufferSize | GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetFramebufferSize(window, width, height);
... | testq %rdi, %rdi
je 0x1c7a3
testq %rsi, %rsi
je 0x1c779
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1c784
movl $0x0, (%rdx)
leaq 0x3712d(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1c795
jmp 0x21bd2
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x17e31
pushq %rax
leaq 0xe9c4(%rip), %... | /anael-seghezzi[P]glfw/src/window.c |
glfwGetWindowFrameSize | GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* handle,
int* left, int* top,
int* right, int* bottom)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (left)
*left = 0;
if (top)
*top = 0;
... | testq %rdi, %rdi
je 0x1c814
testq %rsi, %rsi
je 0x1c7d3
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1c7de
movl $0x0, (%rdx)
testq %rcx, %rcx
je 0x1c7e9
movl $0x0, (%rcx)
testq %r8, %r8
je 0x1c7f5
movl $0x0, (%r8)
leaq 0x370bc(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1c806
jmp 0x21bd7
movl $0x10001, %edi # ... | /anael-seghezzi[P]glfw/src/window.c |
glfwSetWindowOpacity | GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(opacity == opacity);
assert(opacity >= 0.f);
assert(opacity <= 1.f);
_GLFW_REQUIRE_INIT();
if (opacity != opacity || opacity < 0.f || opacity >... | pushq %rax
testq %rdi, %rdi
je 0x1c947
ucomiss %xmm0, %xmm0
jp 0x1c966
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x1c985
movss 0xb718(%rip), %xmm1 # 0x28014
ucomiss %xmm0, %xmm1
jb 0x1c9a4
leaq 0x36fac(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1c932
ucomiss 0xb6fc(%rip), %xmm0 # 0x28014
jbe 0x1c941
cvts... | /anael-seghezzi[P]glfw/src/window.c |
glfwShowWindow | GLFWAPI void glfwShowWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformShowWindow(window);
if (window->focusOnShow)
_glfwPlatformFocusWindow(window);
} | pushq %rbx
testq %rdi, %rdi
je 0x1cada
leaq 0x36e15(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x1cab4
movq %rdi, %rbx
cmpq $0x0, 0x40(%rdi)
je 0x1cac3
popq %rbx
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x17e31
movq %rbx, %rdi
callq 0x2104e
cmpl $0x0, 0x18(%rbx... | /anael-seghezzi[P]glfw/src/window.c |
waitForEvent | static GLFWbool waitForEvent(double* timeout)
{
fd_set fds;
const int fd = ConnectionNumber(_glfw.x11.display);
int count = fd + 1;
#if defined(__linux__)
if (_glfw.linjs.inotify > fd)
count = _glfw.linjs.inotify + 1;
#endif
for (;;)
{
FD_ZERO(&fds);
FD_SET(fd, &fds);
#i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x330cc(%rip), %rdx # 0x538b8
movq 0x1fec0(%rdx), %rax
movl 0x10(%rax), %ecx
movl 0x20840(%rdx), %eax
cmpl %ecx, %eax
movl %ecx, %ebp
cmovgl %eax, %ebp
incl %ebp
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ec... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformSetWindowTitle | void _glfwPlatformSetWindowTitle(_GLFWwindow* window, const char* title)
{
#if defined(X_HAVE_UTF8_STRING)
Xutf8SetWMProperties(_glfw.x11.display,
window->x11.handle,
title, title,
NULL, 0,
NULL, NULL, NULL);
#else
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x32316(%rip), %r15 # 0x538b8
movq 0x1fec0(%r15), %rdi
movq 0x348(%r14), %rsi
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdx
movq %rbx, %rcx
xorl %r8d, %r... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformSetWindowSize | void _glfwPlatformSetWindowSize(_GLFWwindow* window, int width, int height)
{
if (window->monitor)
{
if (window->monitor->window == window)
acquireMonitor(window);
}
else
{
if (!window->resizable)
updateNormalHints(window, width, height);
XResizeWindo... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x219e1
cmpq %r14, 0x18(%rax)
jne 0x21a16
movq %r14, %rdi
callq 0x21368
jmp 0x21a16
movl %edx, %ebx
movl %esi, %ebp
cmpl $0x0, 0x8(%r14)
jne 0x219f8
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x21a2d
leaq 0x31eb9(%rip)... | /anael-seghezzi[P]glfw/src/x11_window.c |
updateNormalHints | static void updateNormalHints(_GLFWwindow* window, int width, int height)
{
XSizeHints* hints = XAllocSizeHints();
if (!window->monitor)
{
if (window->resizable)
{
if (window->minwidth != GLFW_DONT_CARE &&
window->minheight != GLFW_DONT_CARE)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
callq 0x13880
movq %rax, %rbx
cmpq $0x0, 0x40(%r14)
jne 0x21ae4
cmpl $0x0, 0x8(%r14)
je 0x21aba
movl 0x50(%r14), %eax
cmpl $-0x1, %eax
je 0x21a71
movl 0x54(%r14), %ecx
cmpl $-0x1, %ecx
je 0x21a71
orb $0x10, (%rbx)
mo... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformSetWindowSizeLimits | void _glfwPlatformSetWindowSizeLimits(_GLFWwindow* window,
int minwidth, int minheight,
int maxwidth, int maxheight)
{
int width, height;
_glfwPlatformGetWindowSize(window, &width, &height);
updateNormalHints(window, width, height);... | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x31d84(%rip), %r15 # 0x538b8
movq 0x1fec0(%r15), %rdi
movq 0x348(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x13840
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0x21a2d
movq 0x1fec0(%r15), %rdi
callq 0x13610
addq ... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformWindowMaximized | int _glfwPlatformWindowMaximized(_GLFWwindow* window)
{
Atom* states;
unsigned long i;
GLFWbool maximized = GLFW_FALSE;
if (!_glfw.x11.NET_WM_STATE ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_VERT ||
!_glfw.x11.NET_WM_STATE_MAXIMIZED_HORZ)
{
return maximized;
}
const unsig... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x313b2(%rip), %r14 # 0x538b8
movq 0x20440(%r14), %rdx
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x225c5
cmpq $0x0, 0x20458(%r14)
je 0x225c5
cmpq $0x0, 0x20460(%r14)
je 0x225c5
movq 0x348(%rdi), %rsi
movq 0x1fec0(%r14), %rdi
leaq 0x8(%rsp), %r15
leaq 0x10(... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformWindowHovered | int _glfwPlatformWindowHovered(_GLFWwindow* window)
{
Window w = _glfw.x11.root;
while (w)
{
Window root;
int rootX, rootY, childX, childY;
unsigned int mask;
if (!XQueryPointer(_glfw.x11.display, w,
&root, &w, &rootX, &rootY, &childX, &childY, &ma... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x312d0(%rip), %rbx # 0x538b8
movq 0x1fed0(%rbx), %rsi
movq %rsi, (%rsp)
xorl %eax, %eax
testq %rsi, %rsi
je 0x22660
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq 0x1c(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq 0x1fec0(... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformSetWindowFloating | void _glfwPlatformSetWindowFloating(_GLFWwindow* window, GLFWbool enabled)
{
if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_ABOVE)
return;
if (_glfwPlatformWindowVisible(window))
{
const Atom action = enabled ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
sendEventToWM(window,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x3113b(%rip), %r15 # 0x538b8
cmpq $0x0, 0x20440(%r15)
je 0x2296a
cmpq $0x0, 0x20448(%r15)
je 0x2296a
movl %esi, %ebp
movq %rdi, %rbx
movq 0x1fec0(%r15), %rdi
movq 0x348(%rbx), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdx
callq 0x... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformPollEvents | void _glfwPlatformPollEvents(void)
{
_GLFWwindow* window;
#if defined(__linux__)
_glfwDetectJoystickConnectionLinux();
#endif
XPending(_glfw.x11.display);
while (XQLength(_glfw.x11.display))
{
XEvent event;
XNextEvent(_glfw.x11.display, &event);
processEvent(&event);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
callq 0x27966
leaq 0x30d6b(%rip), %r15 # 0x538b8
movq 0x1fec0(%r15), %rdi
callq 0x139d0
movq 0x1fec0(%r15), %rdi
callq 0x130e0
testl %eax, %eax
je 0x23a98
leaq 0x38(%rsp), %rbx
movq 0x1fec0(%r15), %rdi
movq ... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformSetCursorPos | void _glfwPlatformSetCursorPos(_GLFWwindow* window, double x, double y)
{
// Store the new position so it can be recognized later
window->x11.warpCursorPosX = (int) x;
window->x11.warpCursorPosY = (int) y;
XWarpPointer(_glfw.x11.display, None, window->x11.handle,
0,0,0,0, (int) x, (int... | pushq %rbx
subq $0x20, %rsp
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
cvttpd2dq %xmm0, %xmm0
movlpd %xmm0, 0x380(%rdi)
leaq 0x2fd52(%rip), %rbx # 0x538b8
movq 0x1fec0(%rbx), %rax
movq 0x348(%rdi), %rdx
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
movd %xmm1, 0x10(%rsp)
movd %xmm0, 0x8(%rsp)... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformPostEmptyEvent | void _glfwPlatformPostEmptyEvent(void)
{
XEvent event;
memset(&event, 0, sizeof(event));
event.type = ClientMessage;
event.xclient.window = _glfw.x11.helperWindowHandle;
event.xclient.format = 32; // Data is 32-bit longs
event.xclient.message_type = _glfw.x11.NULL_;
XSendEvent(_glfw.x11.di... | pushq %r14
pushq %rbx
subq $0xc8, %rsp
leaq 0x8(%rsp), %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x130f0
movl $0x21, (%rbx)
leaq 0x2fc7c(%rip), %r14 # 0x538b8
movq 0x1fec0(%r14), %rdi
movq 0x1fee0(%r14), %rsi
movq %rsi, 0x20(%rbx)
movl $0x20, 0x30(%rbx)
movq 0x20538(%r14), %rax
movq %rax, 0x28(%rb... | /anael-seghezzi[P]glfw/src/x11_window.c |
glfwPlatformGetScancodeName | const char* _glfwPlatformGetScancodeName(int scancode)
{
if (!_glfw.x11.xkb.available)
return NULL;
const KeySym keysym = XkbKeycodeToKeysym(_glfw.x11.display, scancode, 0, 0);
if (keysym == NoSymbol)
return NULL;
const long ch = _glfwKeySym2Unicode(keysym);
if (ch == -1)
r... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x2f962(%rip), %r14 # 0x538b8
cmpl $0x0, 0x20610(%r14)
je 0x23fb8
movq 0x1fec0(%r14), %rax
movzbl %dil, %esi
xorl %ebx, %ebx
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x132f0
testq %rax, %rax
je 0x23fba
movl %eax, %edi
callq 0x24968
cmpq $-0x1, %rax
je 0x23fb8
movl ... | /anael-seghezzi[P]glfw/src/x11_window.c |
makeContextCurrentGLX | static void makeContextCurrentGLX(_GLFWwindow* window)
{
if (window)
{
if (!glXMakeCurrent(_glfw.x11.display,
window->context.glx.window,
window->context.glx.handle))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
... | pushq %rbx
movq %rdi, %rbx
leaq 0x2dec8(%rip), %rcx # 0x538b8
movq 0x207a8(%rcx), %rax
movq 0x1fec0(%rcx), %rdi
testq %rbx, %rbx
je 0x25a20
movq 0x270(%rbx), %rdx
movq 0x278(%rbx), %rsi
callq *%rax
testl %eax, %eax
jne 0x25a2a
leaq 0x254ad(%rip), %rsi # 0x4aecb
jmp 0x25a46
xorl %esi, %esi
xorl %edx, %edx
callq ... | /anael-seghezzi[P]glfw/src/glx_context.c |
swapIntervalGLX | static void swapIntervalGLX(int interval)
{
_GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (_glfw.glx.EXT_swap_control)
{
_glfw.glx.SwapIntervalEXT(_glfw.x11.display,
window->context.glx.window,
interval);
}
... | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x2de37(%rip), %r14 # 0x538b8
leaq 0x1fe1c(%r14), %rdi
callq 0x24b05
movq %r14, %rdx
cmpl $0x0, 0x20814(%r14)
je 0x25aba
movq 0x207f8(%rdx), %rcx
movq 0x1fec0(%rdx), %rdi
movq 0x278(%rax), %rsi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
cmpl ... | /anael-seghezzi[P]glfw/src/glx_context.c |
glfwGetGLXContext | GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.glx.hand... | pushq %rbx
leaq 0x2dcdf(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x25bf0
cmpl $0x0, 0x1f8(%rdi)
je 0x25bf9
movq 0x270(%rdi), %rbx
jmp 0x25c09
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x25c00
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /anael-seghezzi[P]glfw/src/glx_context.c |
getProcAddressEGL | static GLFWglproc getProcAddressEGL(const char* procname)
{
_GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (window->context.egl.client)
{
GLFWglproc proc = (GLFWglproc) _glfw_dlsym(window->context.egl.client,
procname);
i... | pushq %rbx
movq %rdi, %rbx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x2a5f8(%rip), %rdi # 0x50fe8
callq 0x24b05
movq 0x298(%rax), %rdi
testq %rdi, %rdi
je 0x26a10
movq %rbx, %rsi
callq 0x138b0
testq %rax, %rax
je 0x26a10
popq %rbx
retq
leaq 0x2cea1(%rip), %rax # 0x538b8
movq %rbx, %rdi
popq %rbx
jmpq *... | /anael-seghezzi[P]glfw/src/egl_context.c |
glfwChooseVisualEGL | GLFWbool _glfwChooseVisualEGL(const _GLFWwndconfig* wndconfig,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig,
Visual** visual, int* depth)
{
XVisualInfo* result;
XVisualInfo desired;
EGLConfig native;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %rdi
xorl %ebp, %ebp
movl %ebp, 0x4(%rsp)
movl %ebp, (%rsp)
leaq 0x8(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2652f
testl %eax, %eax
je 0x26b4b
leaq 0x2cdda(%rip), %r12 # 0x538b8
movq 0x20890... | /anael-seghezzi[P]glfw/src/egl_context.c |
glfwGetEGLSurface | GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(EGL_NO_SURFACE);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return EGL_NO_SURFACE;
}
return wind... | pushq %rbx
leaq 0x2cccb(%rip), %rax # 0x538b8
cmpl $0x0, (%rax)
je 0x26c04
cmpl $0x0, 0x1f8(%rdi)
je 0x26c0d
movq 0x290(%rdi), %rbx
jmp 0x26c1d
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x26c14
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /anael-seghezzi[P]glfw/src/egl_context.c |
xmotion::Graph<std::shared_ptr<xmotion::StateExample>, double, xmotion::DefaultIndexer<std::shared_ptr<xmotion::StateExample>>>::GetAllEdges() const | std::vector<typename Graph<State, Transition, StateIndexer>::edge_iterator>
Graph<State, Transition, StateIndexer>::GetAllEdges() const {
std::vector<typename Graph<State, Transition, StateIndexer>::edge_iterator>
edges;
for (auto &vertex_pair : vertex_map_) {
auto vertex = vertex_pair.second;
for (au... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
addq $0x18, %r14
movq %rsp, %r15
movq (%r14), %r14
testq %r14, %r14
je 0x359e
movq 0x10(%r14), %r12
addq $0x20, %r12
movq %r12, %rax
movq (%rax), %rax
movq %rax, (%rsp)
cm... | /rxdu[P]libgraph/src/include/graph/details/graph_impl.hpp |
xmotion::Graph<std::shared_ptr<xmotion::StateExample>, double, xmotion::DefaultIndexer<std::shared_ptr<xmotion::StateExample>>>::Edge::PrintEdge() | void Graph<State, Transition, StateIndexer>::Edge::PrintEdge() {
std::cout << "Edge_t: src - " << src->GetVertexID() << " , dst - "
<< dst->GetVertexID() << " , cost - " << cost << std::endl;
} | pushq %rbx
movq %rdi, %rbx
movq 0x6a0d(%rip), %rdi # 0x9fd8
leaq 0x2b2f(%rip), %rsi # 0x6101
callq 0x20e0
movq (%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rsi
movq %rax, %rdi
callq 0x20d0
leaq 0x2b1f(%rip), %rsi # 0x6110
movq %rax, %rdi
callq 0x20e0
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
mov... | /rxdu[P]libgraph/src/include/graph/details/edge_impl.hpp |
xmotion::Graph<std::shared_ptr<xmotion::StateExample>, double, xmotion::DefaultIndexer<std::shared_ptr<xmotion::StateExample>>>::~Graph() | Graph<State, Transition, StateIndexer>::~Graph() {
for (auto &vertex_pair : vertex_map_) {
delete vertex_pair.second;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x3661
movq 0x10(%r15), %r14
testq %r14, %r14
je 0x3657
movq %r14, %rdi
callq 0x3e76
movq %r14, %rdi
callq 0x20c0
jmp 0x363e
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3ee2
| /rxdu[P]libgraph/src/include/graph/details/graph_impl.hpp |
xmotion::Graph<xmotion::StateExample*, double, xmotion::DefaultIndexer<xmotion::StateExample*>>::AddEdge(xmotion::StateExample*, xmotion::StateExample*, double) | void Graph<State, Transition, StateIndexer>::AddEdge(State sstate, State dstate,
Transition trans) {
auto src_vertex = ObtainVertexFromVertexMap(sstate);
// update transition if edge already exists
auto it = src_vertex->FindEdge(dstate);
if (it != src_vertex... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movsd %xmm0, (%rsp)
movsd %xmm0, 0x10(%rsp)
callq 0x546e
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x54fe
movq 0x10(%r15), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x38fb
movsd (%rsp), %xmm0
movsd %x... | /rxdu[P]libgraph/src/include/graph/details/graph_impl.hpp |
xmotion::Graph<xmotion::StateExample*, double, xmotion::DefaultIndexer<xmotion::StateExample*>>::Edge::PrintEdge() | void Graph<State, Transition, StateIndexer>::Edge::PrintEdge() {
std::cout << "Edge_t: src - " << src->GetVertexID() << " , dst - "
<< dst->GetVertexID() << " , cost - " << cost << std::endl;
} | pushq %rbx
movq %rdi, %rbx
movq 0x6613(%rip), %rdi # 0x9fd8
leaq 0x2735(%rip), %rsi # 0x6101
callq 0x20e0
movq (%rbx), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x20d0
leaq 0x2725(%rip), %rsi # 0x6110
movq %rax, %rdi
callq 0x20e0
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq... | /rxdu[P]libgraph/src/include/graph/details/edge_impl.hpp |
xmotion::Graph<std::shared_ptr<xmotion::StateExample>, double, xmotion::DefaultIndexer<std::shared_ptr<xmotion::StateExample>>>::ObtainVertexFromVertexMap(std::shared_ptr<xmotion::StateExample>) | typename Graph<State, Transition, StateIndexer>::vertex_iterator
Graph<State, Transition, StateIndexer>::ObtainVertexFromVertexMap(State state) {
int64_t state_id = GetStateIndex(state);
auto it = vertex_map_.find(state_id);
if (it == vertex_map_.end()) {
auto new_vertex = new Vertex(state, state_id);
ne... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x3af2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4124
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x3a6c
movq %rsp, %rsi
movq %r15, (%rsi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x41d8
t... | /rxdu[P]libgraph/src/include/graph/details/graph_impl.hpp |
failure | void
failure(const char *fmt, ...)
{
va_list ap;
if (fmt == NULL) {
nextmsg = NULL;
} else {
va_start(ap, fmt);
vsprintf(msgbuff, fmt, ap);
va_end(ap);
nextmsg = msgbuff;
}
} | subq $0xd8, %rsp
testb %al, %al
je 0x391c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x1... | /benesch[P]libarchive/cat/test/main.c |
test_skipping | void
test_skipping(const char *fmt, ...)
{
char buff[1024];
va_list ap;
va_start(ap, fmt);
vsprintf(buff, fmt, ap);
va_end(ap);
/* Use failure() message if set. */
msg = nextmsg;
nextmsg = NULL;
/* failure_start() isn't quite right, but is awfully convenient. */
failure_start(skipping_filename, skipping_line... | subq $0x4e8, %rsp # imm = 0x4E8
testb %al, %al
je 0x3a1f
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx,... | /benesch[P]libarchive/cat/test/main.c |
assertion_file_nlinks | int
assertion_file_nlinks(const char *file, int line,
const char *pathname, int nlinks)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
BY_HANDLE_FILE_INFORMATION bhfi;
int r;
assertion_count(file, line);
r = my_GetFileInformationByName(pathname, &bhfi);
if (r != 0 && bhfi.nNumberOfLinks == (DWORD)nlinks)
ret... | subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq %rdx, 0xa8(%rsp)
movl %ecx, 0xa4(%rsp)
movq 0xb8(%rsp), %rdi
movl 0xb4(%rsp), %esi
callq 0x3d10
movq 0xa8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x31c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x6321
movq 0x20(%rsp), %rax
cmpl 0xa4(%rsp), %eax
jne ... | /benesch[P]libarchive/cat/test/main.c |
is_symlink | static int
is_symlink(const char *file, int line,
const char *pathname, const char *contents)
{
#if defined(_WIN32) && !defined(__CYGWIN__)
(void)pathname; /* UNUSED */
(void)contents; /* UNUSED */
assertion_count(file, line);
/* Windows sort-of has real symlinks, but they're only usable
* by privileged users... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1e8(%rsp)
movl %esi, 0x1e4(%rsp)
movq %rdx, 0x1d8(%rsp)
movq %rcx, 0x1d0(%rsp)
movq 0x1e8(%rsp), %rdi
movl 0x1e4(%rsp), %esi
callq 0x3d10
movq 0x1d8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x31c0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x6875
movq 0x1e8(%rsp)... | /benesch[P]libarchive/cat/test/main.c |
canSymlink | int
canSymlink(void)
{
/* Remember the test result */
static int value = 0, tested = 0;
if (tested)
return (value);
++tested;
assertion_make_file(__FILE__, __LINE__, "canSymlink.0", 0644, 1, "a");
/* Note: Cygwin has its own symlink() emulation that does not
* use the Win32 CreateSymbolicLink() function. */
... | pushq %rax
cmpl $0x0, 0x1ccf0(%rip) # 0x23be8
je 0x6f09
movl 0x1cce4(%rip), %eax # 0x23be4
movl %eax, 0x4(%rsp)
jmp 0x6fa5
movl 0x1ccd9(%rip), %eax # 0x23be8
addl $0x1, %eax
movl %eax, 0x1ccd0(%rip) # 0x23be8
leaq 0x46c1(%rip), %rdi # 0xb5e0
movl $0x73f, %esi # imm = 0x73F
leaq 0x4711(%r... | /benesch[P]libarchive/cat/test/main.c |
test_expand_xz | DEFINE_TEST(test_expand_xz)
{
const char *reffile = "test_expand.xz";
int f;
extract_reference_file(reffile);
f = systemf("%s %s >test.out 2>test.err", testprog, reffile);
if (f == 0 || canXz()) {
assertEqualInt(0, f);
assertTextFileContents("contents of test_expand.xz.\n", "test.out");
assertEmptyFile("tes... | subq $0x18, %rsp
leaq 0x2a97(%rip), %rax # 0xc642
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x7370
leaq 0x1a08f(%rip), %rax # 0x23c50
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
leaq 0x2685(%rip), %rdi # 0xc255
movb $0x0, %al
callq 0x7000
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x9bec
callq 0x72d... | /benesch[P]libarchive/cat/test/test_expand_xz.c |
testing::internal::RegisterTypeParameterizedTestSuite(char const*, testing::internal::CodeLocation) | void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
CodeLocation code_location) {
GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
test_suite_name, code_location);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x284ae
leaq 0x100(%rax), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x28490
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x15832
movq %rsp, %rdi
callq 0x8cf8
addq $0x28, %rsp
popq %rbx
popq %r12
... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == nullptr) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
os_stack_trace_getter_ = new OsStackTraceGetter;
#endif // GTEST_OS_STACK_TRACE_GETTER_
}
ret... | movq 0x210(%rdi), %rax
testq %rax, %rax
je 0x16fbf
retq
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %rdi
callq 0x85c0
leaq 0x356a6(%rip), %rcx # 0x4c678
movq %rcx, (%rax)
movq %rax, 0x210(%rbx)
popq %rbx
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&str... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x1d143
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8420
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1f25c
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x17313
movq %rsp, %r14
movq (%r14), %rdi
movq %rbx, %rsi
call... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream*, testing::UnitTest const&) | void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
OutputJsonKey(stream, kTestsuites, "tests", unit_test.rep... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x146a8(%rip), %rsi # 0x33920
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x8200
leaq 0x50(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x20354
leaq 0x14771(%rip), %rsi # 0x33a0c
movq %rbx, %rdi
callq 0x... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::EscapeJson(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '\\':
case '"':
case '/':
m << '\\' << ch;
break;
case '\b':
m << "\\b";
break;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x17142
movq (%rbx), %rax
movq %rax, (%rsp)
leaq 0x10(%rax), %r12
xorl %ebx, %ebx
leaq 0x18(%rsp), %rbp
cmpq 0x8(%r15), %rbx
jae 0x1f7da
movq (%r15), %rax
m... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator... | void JsonUnitTestResultPrinter::OutputJsonKey(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
const std::string& value,
const std::string& indent,
bool comma) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, 0xc(%rsp)
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x1e124
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
movq %r15, %rdx
callq 0x2eb27
cmpq 0x38(%rsp),... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsRFC3339[abi:cxx11](long) | static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon... | pushq %r14
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rsi, %rax
movq %rdi, %rbx
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
leaq 0x1f0(%rsp), %rsi
movq %rax, %rdi
callq 0x1df23
testb %al, %al
je 0x20604
movl $0x76c, %eax # imm = 0x76C
addl 0x204(%rsp), %eax
leaq 0xc(%rsp), %rs... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::(anonymous namespace)::FailureTest::TestBody() | void TestBody() override {
if (as_error_) {
AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
loc_.line, "") = Message() << error_message_;
} else {
std::cout << error_message_ << std::endl;
}
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
cmpb $0x1, 0x58(%rdi)
jne 0x27bcb
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x17142
leaq 0x38(%r14), %rsi
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
callq 0x8530
movq 0x10(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0xbb05(%rip), %r8 # 0x33695
leaq 0x8(%rsp), %rdi
... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::FormatCxxExceptionMessage[abi:cxx11](char const*, char const*) | static std::string FormatCxxExceptionMessage(const char* description,
const char* location) {
Message message;
if (description != nullptr) {
message << "C++ exception with description \"" << description << "\"";
} else {
message << "Unknown C++ exception";
}
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17142
movq (%r15), %rdi
addq $0x10, %rdi
testq %r14, %r14
je 0x27d4b
leaq 0xd11e(%rip), %rsi # 0x34e44
callq 0x85a0
leaq 0x8(%rsp), %rdi
leaq 0x... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::Message& testing::Message::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x8530
movq %rbx, %rax
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [24]>(char const (&) [24]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17142
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x85a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc4c8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x288d8
movq (%rdi), %rax
callq ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17142
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x85a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc4c8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x28be2
movq (%rdi), %rax
callq ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::internal::GTestFlagSaver::GTestFlagSaver() | GTestFlagSaver() {
also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
break_on_failure_ = GTEST_FLAG(break_on_failure);
catch_exceptions_ = GTEST_FLAG(catch_exceptions);
color_ = GTEST_FLAG(color);
death_test_style_ = GTEST_FLAG(death_test_style);
death_test_use_fork_ = GTEST_FLAG(d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x60(%rdi), %rcx
movq %rcx, 0x50(... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::Message& testing::Message::operator<<<char [6]>(char const (&) [6]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x85a0
movq %rbx, %rax
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
testing::Message& testing::Message::operator<<<char [30]>(char const (&) [30]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
callq 0x85a0
movq %rbx, %rax
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*) | void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc,
TestInfo* test_info) {
// In order to support thread-safe death tests, we need to
// remember the original working directory when the test program
// was first invoked... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x2981d
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x25dba
movq %r13, %rdi
movq %rbp, %rsi
callq 0x8310
leaq 0x8(%rsp), %rdi
... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %r15
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
testq %rdx, %rdx
leaq 0x9c77(%rip), %rsi # 0x33695
cmovneq %rdx, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x8200
movl %ebp, 0x28(%r15)
leaq 0x30(%r15)... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-test-part.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<long>(long const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17142
movq %r15, %rdi
movq %r14, %rsi
callq 0x2d398
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17302
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x29d73
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<int>(int const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17142
movq %r15, %rdi
movq %r14, %rsi
callq 0x2954a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17302
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x29e74
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool>(testing::internal::UnitTestImpl*, bool (testing::internal::UnitTestImpl::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x284ae
addq %r15, %r14
cmpb $0x1, 0x258(%rax)
jne 0x2a04e
testb $0x1, %r12b
je 0x2a03c
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
callq *%r12
addq $0x28, %rsp
popq %rbx
p... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::ParameterizedTestSuiteRegistry::~ParameterizedTestSuiteRegistry() | ~ParameterizedTestSuiteRegistry() {
for (auto& test_suite_info : test_suite_infos_) {
delete test_suite_info;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x2a35a
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2a354
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x2a341
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2c05a
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h |
testing::internal::GetRandomSeedFromFlag(int) | inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
const unsigned int raw_seed = (random_seed_flag == 0) ?
static_cast<unsigned int>(GetTimeInMillis()) :
static_cast<unsigned int>(random_seed_flag);
// Normalizes the actual seed to range [1, kMaxRandomSeed] such that
// it's easy to type.
... | movl %edi, %eax
testl %edi, %edi
jne 0x2a5d5
pushq %rax
callq 0x16fde
addq $0x8, %rsp
decl %eax
movl $0x1869f, %ecx # imm = 0x1869F
xorl %edx, %edx
divl %ecx
leal 0x1(%rdx), %eax
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::GetNextRandomSeed(int) | inline int GetNextRandomSeed(int seed) {
GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
<< "Invalid random seed " << seed << " - must be in [1, "
<< kMaxRandomSeed << "].";
const int next_seed = seed + 1;
return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
} | pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax # imm = 0x1869F
jb 0x2a6a4
leaq 0x9f6d(%rip), %rdx # 0x3459e
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x96, %ecx
callq 0x26702
movq 0x2299e(%rip), %rdi # 0x4cfe8
leaq 0xa2d3(%rip), %rsi # 0x34924
callq 0x... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
void testing::internal::ShuffleRange<int>(testing::internal::Random*, int, int, std::vector<int, std::allocator<int>>*) | void ShuffleRange(internal::Random* random, int begin, int end,
std::vector<E>* v) {
const int size = static_cast<int>(v->size());
GTEST_CHECK_(0 <= begin && begin <= size)
<< "Invalid shuffle range start " << begin << ": must be in range [0, "
<< size << "].";
GTEST_CHECK_(begin <= ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rcx), %r15
subq (%rcx), %r15
shrq $0x2, %r15
testl %esi, %esi
js 0x2a71f
cmpl %ebp, %r15d
jge 0x2a797
leaq 0x9e78(%rip), %rdx # 0x3459e
leaq 0x4(%rsp), %rdi
pushq ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r15
cmpl (%r14), %r12d
jge 0x2a993
movslq %r12d, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %rdi
callq 0x14a6c
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x27dcf
testb %... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<wchar_t>(int*, wchar_t**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r12
leaq 0x8(%rsp), %r15
cmpl (%r14), %r12d
jge 0x2aab9
movslq %r12d, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %rdi
callq 0x14afc
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x27dcf
testb %... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest.cc |
testing::internal::DeathTestImpl::DeathTestImpl(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>) | DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher)
: statement_(a_statement),
matcher_(std::move(matcher)),
spawned_(false),
status_(-1),
outcome_(IN_PROGRESS),
read_fd_(-1),
write_fd_(-1) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2309c
leaq 0x21b70(%rip), %rax # 0x4c800
movq %rax, (%r15)
movq %r14, 0x8(%r15)
andq $0x0, 0x20(%r15)
movups 0x8(%rbx), %xmm0
andq $0x0, 0x10(%rbx)
movups %xmm0, 0x18(%r15)
andq $0x0, 0x8(%rbx)
leaq 0x21e72(%rip), %rax # 0x... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::~Matcher() | class GTEST_API_ Matcher<const std::string&>
: public internal::MatcherBase<const std::string&> {
public:
Matcher() {}
explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<const std::string&>(impl) {}
// Allows the user to write str instead of Eq(str) sometimes, ... | pushq %rbx
movq %rdi, %rbx
callq 0x2ac3a
movq %rbx, %rdi
popq %rbx
jmp 0x8580
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-matchers.h |
testing::AssertionResult& testing::AssertionResult::operator<<<testing::TestPartResult>(testing::TestPartResult const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17142
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x2704c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc4c8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b742
movq (%rdi), %rax
callq... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [14]>(char const (&) [14]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17142
movq (%r15), %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x85a0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc4c8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b7b2
movq (%rdi), %rax
callq ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest.h |
testing::internal::StreamingListener::OnTestIterationStart(testing::UnitTest const&, int) | void OnTestIterationStart(const UnitTest& /* unit_test */,
int iteration) override {
SendLn("event=TestIterationStart&iteration=" +
StreamableToString(iteration));
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
movl %edx, (%rsi)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x29e32
leaq 0x8643(%rip), %rsi # 0x34826
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x12689
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2cbaa
leaq 0x8(%rsp), %rdi
callq 0x8cf8... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestCaseStart(testing::TestSuite const&) | void OnTestCaseStart(const TestCase& test_case) override {
SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x85f6(%rip), %rsi # 0x3484a
leaq 0x30(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x8200
movq 0x8(%r14), %rdx
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x126ad
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2cbaa
le... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int) | void OnTestIterationEnd(const UnitTest& unit_test,
int /* iteration */) override {
SendLn("event=TestIterationEnd&passed=" +
FormatBool(unit_test.Passed()) + "&elapsed_time=" +
StreamableToString(unit_test.elapsed_time()) + "ms");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1c91c
movzbl %al, %edx
leaq 0xb0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2cc06
leaq 0x80b9(%rip), %rsi # 0x348e8
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq 0x12689
leaq 0x8079(%rip), %rdx # 0... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Send(const std::string& message) override {
GTEST_CHECK_(sockfd_ != -1)
<< "Send() can be called only when there is a connection.";
const auto len = static_cast<size_t>(message.length());
if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
GTEST_LOG_(WARNIN... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x2ca98
leaq 0x7b47(%rip), %rdx # 0x3459e
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x44f, %ecx # imm = 0x44F
callq 0x26702
movq 0x20578(%rip), %rdi # 0x4cfe8
leaq 0x7cb4(%rip), %rsi ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->Ma... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0x89d0
movq %rax, %rbx
testq %rax, %rax
jne 0x2d8c7
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0x80d0
testl %eax, %eax
je 0x2d8c7
movl %eax, %ebp
leaq 0x402d(%r... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::Message& testing::Message::operator<<<double>(double const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
addq $0x10, %rdi
movsd (%rsi), %xmm0
callq 0x8ab0
movq %rbx, %rax
popq %rbx
retq
nop
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> const&) const | Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } | movl (%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # imm = 0x7FFFFF
setne %al
testb %al, %cl
jne 0x2e144
movl (%rsi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::FloatingPoint<double>::DistanceBetweenSignAndMagnitudeNumbers(unsigned long const&, unsigned long const&) | static Bits SignAndMagnitudeToBiased(const Bits &sam) {
if (kSignBitMask & sam) {
// sam represents a negative number.
return ~sam + 1;
} else {
// sam represents a positive number.
return kSignBitMask | sam;
}
} | movq (%rdi), %rcx
movq %rcx, %rdx
negq %rdx
movq %rcx, %rax
btsq $0x3f, %rax
testq %rcx, %rcx
cmovsq %rdx, %rax
movq (%rsi), %rcx
movq %rcx, %rdx
negq %rdx
movq %rcx, %rsi
btsq $0x3f, %rsi
testq %rcx, %rcx
cmovsq %rdx, %rsi
movq %rax, %rcx
subq %rsi, %rcx
negq %rcx
subq %rsi, %rax
cmovbq %rcx, %rax
retq
| /walterzhaoJR[P]leveldb/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
ConcreteVisitor::visit(ASTFrom*) | std::shared_ptr<VisitorResult> visit(ASTFrom *from) override {
auto lj = std::make_shared<LogicalJoin>();
std::vector<std::string> colls;
for (auto &coll: from->getCollections()) {
colls.push_back(coll.getName());
}
lj->setCollections(colls);
return lj;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x2b65
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0x8(%r12), %r15
movq 0x10(%r12), %r12
cmpq %r12, %r15
je 0x2a08
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b80
... | /woland84[P]ast-visitor-pattern/ConcreteVisitor.hh |
ConcreteVisitor::visit(ASTWhere*) | std::shared_ptr<VisitorResult> visit(ASTWhere *where) override {
auto lop = std::static_pointer_cast<LogicalOperation>(where->getFilterOperation()->accept(this));
return std::make_shared<LogicalFilter>(lop);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdx), %rsi
movq (%rsi), %rcx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rdx
callq *(%rcx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32f7
leaq 0x8(%rsp), %rdi
callq 0x2942
movq %rsp, %rdi
movq %r15, %rsi
call... | /woland84[P]ast-visitor-pattern/ConcreteVisitor.hh |
LowMC_test_vector_256_256_38_1 | static int LowMC_test_vector_256_256_38_1(void) {
const uint8_t key[32] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0... | subq $0x68, %rsp
movq 0x1cf55(%rip), %rax # 0x21470
movq %rax, 0x40(%rsp)
movq 0x1cf51(%rip), %rax # 0x21478
movq %rax, 0x48(%rsp)
movq 0x1cf4d(%rip), %rax # 0x21480
movq %rax, 0x50(%rsp)
movq 0x1cf49(%rip), %rax # 0x21488
movq %rax, 0x58(%rsp)
movq 0x1cf45(%rip), %rax # 0x21490
movq %rax, 0x20(%rsp... | /IAIK[P]Picnic/tests/lowmc_test.c |
LowMC_test_vector_129_129_4_4 | static int LowMC_test_vector_129_129_4_4(void) {
const uint8_t key[17] = {
0x30, 0xf3, 0x34, 0x88, 0x53, 0x2d, 0x7e, 0xb8, 0xa5,
0xf8, 0xfb, 0x4f, 0x2e, 0x63, 0xba, 0x56, 0x0,
};
const uint8_t plaintext[17] = {
0xc2, 0x6a, 0x5d, 0xf9, 0x6, 0x15, 0x8d, 0xcb, 0x6a,
0xc7, 0x89, 0x1d, 0xa9, 0... | subq $0x58, %rsp
movq 0x1cdc5(%rip), %rax # 0x216d0
movq %rax, 0x40(%rsp)
movq 0x1cdc1(%rip), %rax # 0x216d8
movq %rax, 0x48(%rsp)
movb 0x1cdbe(%rip), %al # 0x216e0
movb %al, 0x50(%rsp)
movq 0x1cdc3(%rip), %rax # 0x216f0
movq %rax, 0x20(%rsp)
movq 0x1cdbf(%rip), %rax # 0x216f8
movq %rax, 0x28(%rsp)... | /IAIK[P]Picnic/tests/lowmc_test.c |
LowMC_test_vector_192_192_4_1 | static int LowMC_test_vector_192_192_4_1(void) {
const uint8_t key[24] = {
0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
};
const uint8_t plaintext[24] = {
0xab, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
... | subq $0x58, %rsp
movq 0x1c955(%rip), %rax # 0x212f0
movq %rax, 0x40(%rsp)
movq 0x1c951(%rip), %rax # 0x212f8
movq %rax, 0x48(%rsp)
movq 0x1c94d(%rip), %rax # 0x21300
movq %rax, 0x50(%rsp)
movq 0x1c951(%rip), %rax # 0x21310
movq %rax, 0x20(%rsp)
movq 0x1c94d(%rip), %rax # 0x21318
movq %rax, 0x28(%rsp... | /IAIK[P]Picnic/tests/lowmc_test.c |
LowMC_test_vector_192_192_4_2 | static int LowMC_test_vector_192_192_4_2(void) {
const uint8_t key[24] = {
0x81, 0xb8, 0x5d, 0xfe, 0x40, 0xf6, 0x12, 0x27, 0x5a, 0xa3, 0xf9, 0x19,
0x91, 0x39, 0xeb, 0xaa, 0xe8, 0xdf, 0xf8, 0x36, 0x6f, 0x2d, 0xd3, 0x4e,
};
const uint8_t plaintext[24] = {
0xb8, 0x65, 0xcc, 0xf3, 0xfc, 0xda, 0x8d, ... | subq $0x58, %rsp
movq 0x1c925(%rip), %rax # 0x21350
movq %rax, 0x40(%rsp)
movq 0x1c921(%rip), %rax # 0x21358
movq %rax, 0x48(%rsp)
movq 0x1c91d(%rip), %rax # 0x21360
movq %rax, 0x50(%rsp)
movq 0x1c921(%rip), %rax # 0x21370
movq %rax, 0x20(%rsp)
movq 0x1c91d(%rip), %rax # 0x21378
movq %rax, 0x28(%rsp... | /IAIK[P]Picnic/tests/lowmc_test.c |
LowMC_test_vector_192_192_4_3 | static int LowMC_test_vector_192_192_4_3(void) {
const uint8_t key[24] = {
0x24, 0x5, 0x97, 0x8f, 0xda, 0xad, 0x9b, 0x6d, 0x8d, 0xcd, 0xd1, 0x8a,
0xc, 0x2c, 0xe, 0xc6, 0x8b, 0x69, 0xdd, 0xa, 0x37, 0x54, 0xfe, 0x38,
};
const uint8_t plaintext[24] = {
0x33, 0xe8, 0xb4, 0x55, 0x2e, 0x95, 0xef, ... | subq $0x58, %rsp
movq 0x1c8f5(%rip), %rax # 0x213b0
movq %rax, 0x40(%rsp)
movq 0x1c8f1(%rip), %rax # 0x213b8
movq %rax, 0x48(%rsp)
movq 0x1c8ed(%rip), %rax # 0x213c0
movq %rax, 0x50(%rsp)
movq 0x1c8f1(%rip), %rax # 0x213d0
movq %rax, 0x20(%rsp)
movq 0x1c8ed(%rip), %rax # 0x213d8
movq %rax, 0x28(%rsp... | /IAIK[P]Picnic/tests/lowmc_test.c |
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.