name string | code string | asm string | file string |
|---|---|---|---|
blns::Blns::readFile() | void blns::Blns::readFile() {
std::ifstream blnsFile = std::filesystem::path(__FILE__).parent_path()
/ ".." / ".." / "blns.txt";
// If this assertion fails, ensure that you have correctly
// downloaded blns.txt at the root of the project during cmake build
assert(blnsFile.i... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x348, %rsp # imm = 0x348
leaq 0xb11(%rip), %rsi # 0x3004
leaq 0x118(%rsp), %rbx
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2814
leaq 0xa0(%rsp), %rdi
movq %rbx, %rsi
callq 0x2220
leaq 0xb3d(%rip), %rsi # 0x305c
leaq 0x78(%rsp), %rdi
movl $0x2, %edx
... | /eliabieri[P]blnscpp/src/blns/blns.cpp |
el::base::utils::Str::convertAndAddToBuff(unsigned long, int, char*, char const*, bool) | char* Str::convertAndAddToBuff(std::size_t n, int len, char* buf, const char* bufLim, bool zeroPadded) {
char localBuff[10] = "";
char* p = localBuff + sizeof(localBuff) - 2;
if (n > 0) {
for (; n > 0 && p > localBuff && len > 0; n /= 10, --len)
*--p = static_cast<char>(n % 10 + '0');
} else {
*--... | pushq %r14
pushq %rbx
movq %rdx, %r9
movw $0x0, -0x8(%rsp)
movq $0x0, -0x10(%rsp)
testq %rdi, %rdi
je 0x61aa2
testl %esi, %esi
jle 0x61aaf
movq %rdi, %rdx
leaq -0x9(%rsp), %r10
movabsq $-0x3333333333333333, %r11 # imm = 0xCCCCCCCCCCCCCCCD
leaq -0x10(%rsp), %rbx
movl %esi, %r14d
movq %rdx, %rdi
movq %rdx, %rax
mulq %r11... | /nwneetools[P]nwnsc/_NwnUtilLib/easylogging++.cc |
JSON::ExtractString(wchar_t const**, std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>&) | bool JSON::ExtractString(const wchar_t **data, std::wstring &str)
{
str = L"";
while (**data != 0)
{
// Save the char so we can change it if need be
wchar_t next_char = **data;
// Escaping something?
if (next_char == L'\\')
{
// Move over the escape char
(*data)++;
// Deal with the escape... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
leaq 0xda12(%rip), %rcx # 0x7e910
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x33ac0
movq (%r14), %rcx
leaq 0xd917(%rip), %r15 # 0x7e82c
movl (%rcx), %esi
cmpl $0x5c, %esi
je 0x70f55
testl %esi, %esi
je 0x71049
cm... | /nwneetools[P]nwnsc/_NwnUtilLib/JSON.cpp |
main | int
main(int argc, char **argv)
{
test_params p = parse_args(argc, argv);
VMEMcache *vc = vmemcache_new();
vmemcache_set_size(vc, p.pool_size);
vmemcache_set_extent_size(vc, p.extent_size);
vmemcache_set_eviction_policy(vc, VMEMCACHE_REPLACEMENT_LRU);
if (vmemcache_add(vc, p.dir))
UT_FATAL("vmemcache_new: %s (... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1098, %rsp # imm = 0x1098
movq %rsi, %rbx
movl %edi, %r12d
leaq -0x10a8(%rbp), %r14
movq $0x0, -0x38(%rbp)
movl $0x1018, %edx # imm = 0x1018
movq %r14, %rdi
xorl %esi, %esi
callq 0x10e0
movq $0x100000, -0x10(%r... | /pmem[P]vmemcache/tests/vmemcache_test_utilization.c |
parse_unsigned | static unsigned
parse_unsigned(const char *valname, const char *prog)
{
unsigned val;
if (str_to_unsigned(optarg, &val) != 0) {
fprintf(stderr, "invalid %s value\n", valname);
printf(usage_str, prog);
exit(1);
}
return val;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x25e2(%rip), %rax # 0x3fd8
movq (%rax), %r15
leaq -0x30(%rbp), %r12
andq $0x0, (%r12)
callq 0x1050
movq %rax, %r13
andl $0x0, (%rax)
pushq $0xa
popq %rdx
movq %r15, %rdi
movq %r12, %rs... | /pmem[P]vmemcache/tests/vmemcache_test_utilization.c |
salsa20::salsa20(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&) | salsa20::salsa20(const std::string &key, const std::string &nonce)
{
/* if key size is not same sizes::key_size
* copy part of key, or all key bytes and fill other by 0x0
*/
std::array<uint8_t, sizes::key_size> key_array;
key_array.fill(0x0);
long minimal_size = sizes::key_size < key.length() ... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x2851
movq (%rsi), %rsi
cmpq $0x20, %rax
movl $0x20, %edx
cmovbq %rax, %rdx
movq %rsp, %rdi
callq 0x2100
xorps %xmm0, %xmm0
movq (%r14), %rax
... | /Elesarf[P]salsa20/src/salsa20.cpp |
checkWindowSize(GLFWwindow*, int, int, bool) | static void
checkWindowSize(GLFWwindow* window, int width, int height, bool fatal)
{
int w, h;
glfwGetWindowSize(window, &w, &h);
if (w == width && h == height) {
return;
}
std::cerr << (fatal ? "error" : "warning") << ": "
<< "expected window size " << width << "x" << height
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
leaq 0x4(%rsp), %r15
movq %rsp, %rdx
movq %r15, %rsi
callq 0xd0eb
cmpl %r14d, (%r15)
jne 0x7e1d
cmpl %ebp, (%rsp)
je 0x7f15
leaq 0x2d02c(%rip), %rax # 0x34e50
leaq 0x111e5(%rip), %rsi # 0x19010
testb %bl, %bl... | /apitrace[P]apitrace-tests/apps/gl/window_resize.cpp |
glfwExtensionSupported | GLFWAPI int glfwExtensionSupported(const char* extension)
{
_GLFWwindow* window;
assert(extension != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Canno... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x889a
leaq 0x37ad7(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x87f7
movq %rdi, %rbx
movl $0x2059c, %edi # imm = 0x2059C
addq 0x36877(%rip), %rdi # 0x3efc8
callq 0x15965
testq %rax, %rax
je 0x8803
cmpb $0x... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/context.c |
glfwStringInExtensionString | GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions)
{
const char* start = extensions;
for (;;)
{
const char* where;
const char* terminator;
where = strstr(start, string);
if (!where)
return GLFW_FALSE;
terminator = where + ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x70f0
testq %rax, %rax
je 0x8902
movq %rax, %r15
movq %rbx, %rdi
callq 0x7270
addq %r15, %rax
cmpq %r14, %r15
je 0x88ee
cmpb $0x20, -0x1(%r15)
jne 0x88fb
movzbl (%rax), %edx
movl $0x2, %ecx
testb $-0x21, %dl
je 0x890... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/context.c |
glfw_fmaxf | float _glfw_fmaxf(float a, float b)
{
if (a != a)
return b;
else if (b != b)
return a;
else if (a > b)
return a;
else
return b;
} | ucomiss %xmm0, %xmm0
jp 0x8b53
ucomiss %xmm1, %xmm1
jp 0x8b50
maxss %xmm1, %xmm0
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwInputError | void _glfwInputError(int code, const char* format, ...)
{
_GLFWerror* error;
char description[_GLFW_MESSAGE_SIZE];
if (format)
{
va_list vl;
va_start(vl, format);
vsnprintf(description, sizeof(description), format, vl);
va_end(vl);
description[sizeof(descriptio... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movl %edi, %ebx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x8bb6
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwInit | GLFWAPI int glfwInit(void)
{
if (_glfw.initialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
_glfw.hints.init = _glfwInitHints;
if (!_glfwPlatformInit())
{
terminate();
return GLFW_FALSE;
}
if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
!_glf... | pushq %rbp
pushq %rbx
pushq %rax
leaq 0x37365(%rip), %rbx # 0x40210
movl $0x1, %ebp
cmpl $0x0, (%rbx)
jne 0x8f6a
xorl %ebp, %ebp
movl $0x21808, %edx # imm = 0x21808
movq %rbx, %rdi
xorl %esi, %esi
callq 0x72f0
movq 0x366cf(%rip), %rax # 0x3f5a0
movq %rax, 0x8(%rbx)
movl 0x366cd(%rip), %eax # 0x3f5a... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwInitHint | GLFWAPI void glfwInitHint(int hint, int value)
{
switch (hint)
{
case GLFW_JOYSTICK_HAT_BUTTONS:
_glfwInitHints.hatButtons = value;
return;
case GLFW_COCOA_CHDIR_RESOURCES:
_glfwInitHints.ns.chdir = value;
return;
case GLFW_COCOA_MENUBAR:
... | cmpl $0x51002, %edi # imm = 0x51002
je 0x90c6
movl %edi, %edx
cmpl $0x51001, %edi # imm = 0x51001
je 0x90bf
cmpl $0x50001, %edx # imm = 0x50001
jne 0x90cd
movl %esi, 0x364e2(%rip) # 0x3f5a0
retq
movl %esi, 0x364e3(%rip) # 0x3f5a8
retq
movl %esi, 0x364d8(%rip) # 0x3f5a4
retq
leaq 0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwGetError | GLFWAPI int glfwGetError(const char** description)
{
_GLFWerror* error;
int code = GLFW_NO_ERROR;
if (description)
*description = NULL;
if (_glfw.initialized)
error = _glfwPlatformGetTls(&_glfw.errorSlot);
else
error = &_glfwMainThreadError;
if (error)
{
co... | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x9117
movq $0x0, (%rbx)
leaq 0x370f2(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x9136
movl $0x20594, %edi # imm = 0x20594
addq 0x35e99(%rip), %rdi # 0x3efc8
callq 0x15965
jmp 0x913d
leaq 0x588db(%rip), %rax # 0x61a18
testq %rax, %rax
je 0x916a
testq ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/init.c |
glfwInputKey | void _glfwInputKey(_GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key >= 0 && key <= GLFW_KEY_LAST)
{
GLFWbool repeated = GLFW_FALSE;
if (action == GLFW_RELEASE && window->keys[key] == GLFW_RELEASE)
return;
if (action == GLFW_PRESS && window->keys[k... | cmpl $0x15c, %esi # imm = 0x15C
ja 0x91d5
movl %esi, %eax
testl %ecx, %ecx
jne 0x9198
cmpb $0x0, 0x88(%rdi,%rax)
je 0x91f6
movl %ecx, %r9d
cmpl $0x1, %ecx
jne 0x91b2
cmpb $0x1, 0x88(%rdi,%rax)
movl $0x2, %r9d
cmovnel %ecx, %r9d
testl %ecx, %ecx
je 0x91bb
movl %ecx, %r10d
jmp 0x91c4
movb $0x3, %r10b
cmpl $0x0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwInputChar | void _glfwInputChar(_GLFWwindow* window, uint32_t codepoint, int mods, GLFWbool plain)
{
if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.charmods)
window->callback... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %ebx
cmpl $0x20, %esi
setb %al
leal -0x7f(%rbx), %ecx
cmpl $0x21, %ecx
setb %cl
orb %al, %cl
jne 0x9258
movq %rdi, %r14
movq 0x338(%rdi), %rcx
testq %rcx, %rcx
je 0x923d
movl %edx, %eax
andl $-0x31, %eax
cmpl $0x0, 0x78(%r14)
cmovnel %edx, %eax
movq %r14, %rdi... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwInputMouseClick | void _glfwInputMouseClick(_GLFWwindow* window, int button, int action, int mods)
{
if (button < 0 || button > GLFW_MOUSE_BUTTON_LAST)
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (action == GLFW_RELEASE && window->stickyMouseButtons)
windo... | cmpl $0x7, %esi
ja 0x92a6
movl %ecx, %eax
andl $-0x31, %ecx
cmpl $0x0, 0x78(%rdi)
cmovnel %eax, %ecx
testl %edx, %edx
je 0x9285
movl %edx, %eax
jmp 0x928d
movb $0x3, %al
cmpl $0x0, 0x74(%rdi)
je 0x9281
movl %esi, %r8d
movb %al, 0x80(%rdi,%r8)
movq 0x308(%rdi), %rax
testq %rax, %rax
je 0x92a6
jmpq *%rax
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwInputCursorPos | void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
{
if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
return;
window->virtualCursorPosX = xpos;
window->virtualCursorPosY = ypos;
if (window->callbacks.cursorPos)
window->callbacks.cursorPos... | movsd 0x1e8(%rdi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x92c7
jp 0x92c7
movsd 0x1f0(%rdi), %xmm2
ucomisd %xmm1, %xmm2
jne 0x92c7
jnp 0x92e5
movsd %xmm0, 0x1e8(%rdi)
movsd %xmm1, 0x1f0(%rdi)
movq 0x310(%rdi), %rax
testq %rax, %rax
je 0x92e5
jmpq *%rax
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwInitGamepadMappings | void _glfwInitGamepadMappings(void)
{
int jid;
size_t i;
const size_t count = sizeof(_glfwDefaultMappings) / sizeof(char*);
_glfw.mappings = calloc(count, sizeof(_GLFWmapping));
for (i = 0; i < count; i++)
{
if (parseMapping(&_glfw.mappings[_glfw.mappingCount], _glfwDefaultMappings[i]... | pushq %r15
pushq %r14
pushq %rbx
movl $0x18b, %edi # imm = 0x18B
movl $0xf5, %esi
callq 0x7380
leaq 0x36e52(%rip), %r14 # 0x40210
movq %rax, 0x20588(%r14)
xorl %ebx, %ebx
leaq 0x361e2(%rip), %r15 # 0x3f5b0
movslq 0x20590(%r14), %rax
imulq $0xf5, %rax, %rdi
addq 0x20588(%r14), %rdi
movq (%r15,%rbx,8),... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
findValidMapping | static _GLFWmapping* findValidMapping(const _GLFWjoystick* js)
{
_GLFWmapping* mapping = findMapping(js->guid);
if (mapping)
{
int i;
for (i = 0; i <= GLFW_GAMEPAD_BUTTON_LAST; i++)
{
if (!isValidElementForJoystick(mapping->buttons + i, js))
return NULL... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
addq $0xc0, %rdi
callq 0xad90
movq %rax, %rbx
testq %rax, %rax
je 0x99c6
movl $0xa1, %r15d
leaq (%rbx,%r15), %rdi
movq %r14, %rsi
callq 0xb3f5
testl %eax, %eax
je 0x99c4
addq $0x4, %r15
cmpq $0xdd, %r15
jne 0x9982
movl $0xdd, %r15d
leaq (%rbx,%r15), %rdi
movq %r14, %rsi
... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwGetInputMode | GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (mode)
{
case GLFW_CURSOR:
return window->cursorMode;
case GLFW_STICKY_KEYS:
return wind... | pushq %rbx
testq %rdi, %rdi
je 0x9bda
leaq 0x3669f(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x9b98
movl %esi, %edx
leal -0x33001(%rdx), %eax
cmpl $0x4, %eax
ja 0x9bc1
leaq 0xfc9e(%rip), %rcx # 0x19828
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x7c(%rdi), %ebx
jmp 0x9bd6
xorl %ebx, %ebx
movl ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwGetKeyName | GLFWAPI const char* glfwGetKeyName(int key, int scancode)
{
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (key != GLFW_KEY_UNKNOWN)
{
if (key != GLFW_KEY_KP_EQUAL &&
(key < GLFW_KEY_KP_0 || key > GLFW_KEY_KP_ADD) &&
(key < GLFW_KEY_APOSTROPHE || key > GLFW_KEY_WORLD_2))
{
... | pushq %rax
leaq 0x36441(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x9e0c
cmpl $-0x1, %edi
je 0x9e04
cmpl $0x150, %edi # imm = 0x150
je 0x9dfd
leal -0x14f(%rdi), %eax
cmpl $-0xf, %eax
setb %al
leal -0xa3(%rdi), %ecx
cmpl $-0x7c, %ecx
setb %cl
testb %cl, %al
jne 0x9e1a
callq 0x14d7d
movl %eax, %esi
movl %... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
retur... | pushq %rbx
testq %rdi, %rdi
je 0x9eda
leaq 0x36393(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x9ea8
movl %esi, %edx
leal -0x15d(%rdx), %eax
cmpl $0xfffffec2, %eax # imm = 0xFFFFFEC2
ja 0x9eba
leaq 0x29ee2(%rip), %rsi # 0x33d7a
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
c... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwGetMouseButton | GLFWAPI int glfwGetMouseButton(GLFWwindow* handle, int button)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (button < GLFW_MOUSE_BUTTON_1 || button > GLFW_MOUSE_BUTTON_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Inval... | pushq %rbx
testq %rdi, %rdi
je 0x9f5b
leaq 0x3630a(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x9f29
movl %esi, %edx
cmpl $0x8, %esi
jb 0x9f3b
leaq 0x29ebc(%rip), %rsi # 0x33dd5
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x8b57
jmp 0x9f57
xorl %ebx, %ebx
movl $0x10001, %e... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
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 0x9fe1
testq %rsi, %rsi
je 0x9f8b
movq $0x0, (%rsi)
testq %rdx, %rdx
je 0x9f97
movq $0x0, (%rdx)
leaq 0x36272(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0x9fd3
cmpl $0x34003, 0x7c(%rdi) # imm = 0x34003
jne 0x14a05
testq %rsi, %rsi
je 0x9fc1
movsd 0x1e8(%rdi), %xmm0
movsd %xmm0, (%rsi)
testq %... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwSetCursorPos | GLFWAPI void glfwSetCursorPos(GLFWwindow* handle, double xpos, double ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (xpos != xpos || xpos < -DBL_MAX || xpos > DBL_MAX ||
ypos != ypos || ypos < -DBL_MAX || ypos > DBL_MAX)
{
_gl... | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xa0d7
leaq 0x361fa(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xa0ac
ucomisd 0xf7d9(%rip), %xmm0 # 0x19800
ja 0xa094
ucomisd %xmm0, %xmm0
jp 0xa094
movsd 0xf7d1(%rip), %xmm2 # 0x19808
ucomisd %xmm0, %xmm2
ja 0xa094
ucomisd 0xf7bb(%rip), %xmm1 # 0x19800
ja... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwCreateCursor | GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
{
_GLFWcursor* cursor;
assert(image != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
cursor = calloc(1, sizeof(_GLFWcursor));
cursor->next = _glfw.cursorListHead;
_glfw.cursorListHead = cursor;
if (!_glfwPlatfo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xa17a
leaq 0x36106(%rip), %r12 # 0x40210
cmpl $0x0, (%r12)
je 0xa15e
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x7380
movq %rax, %rbx
movq 0x3e8(%r12), %rax
movq %rax, (%rbx)
movq %rbx, 0x3e8(%r... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
glfwSetJoystickUserPointer | GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT();
js = _glfw.joysticks + jid;
if (!js->present)
return;
js->userPointer = pointer;
} | pushq %rax
testl %edi, %edi
js 0xaab3
cmpl $0x10, %edi
jge 0xaad2
leaq 0x35796(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xaaa4
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0xaaa2
addq %rcx, %rax
addq $0x408, %rax # imm = 0x408
movq %rsi, 0xb8(%rax)
popq %r... | /apitrace[P]apitrace-tests/thirdparty/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 0xab45
cmpl $0x10, %edi
jge 0xab64
leaq 0x3570e(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xab2c
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0xab3e
addq %rcx, %rax
addq $0x408, %rax # imm = 0x408
movq 0xb8(%rax), %rbx
jmp 0xa... | /apitrace[P]apitrace-tests/thirdparty/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 0xae54
cmpl $0x10, %edi
jge 0xae73
leaq 0x3541c(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xae36
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0xae48
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x408
... | /apitrace[P]apitrace-tests/thirdparty/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 0xaf05
cmpl $0x10, %edi
jge 0xaf24
leaq 0x35366(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xaee6
movl %edi, %ecx
imulq $0x2018, %rcx, %rcx # imm = 0x2018
cmpl $0x0, 0x408(%rax,%rcx)
je 0xaef8
leaq (%rax,%rcx), %r14
addq $0x408, %r14 # imm = 0x408
... | /apitrace[P]apitrace-tests/thirdparty/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 %r12
pushq %rbx
pushq %rax
testl %edi, %edi
js 0xb197
cmpl $0x10, %edi
jge 0xb1b6
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb1d5
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x3528f(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xb085
movl %edi, %e... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/input.c |
isValidElementForJoystick | static GLFWbool isValidElementForJoystick(const _GLFWmapelement* e,
const _GLFWjoystick* js)
{
if (e->type == _GLFW_JOYSTICK_HATBIT && (e->index >> 4) >= js->hatCount)
return GLFW_FALSE;
else if (e->type == _GLFW_JOYSTICK_BUTTON && e->index >= js->buttonCount)
... | movzbl (%rdi), %eax
cmpl $0x1, %eax
je 0xb42b
cmpl $0x2, %eax
je 0xb41d
cmpl $0x3, %eax
jne 0xb434
movzbl 0x1(%rdi), %ecx
shrl $0x4, %ecx
cmpl %ecx, 0x30(%rsi)
jle 0xb43a
cmpl $0x1, %eax
je 0xb42b
cmpl $0x2, %eax
jne 0xb434
movzbl 0x1(%rdi), %ecx
cmpl %ecx, 0x20(%rsi)
jle 0xb43a
cmpl $0x1, %eax
jne 0xb434
movzbl 0x1(%r... | /apitrace[P]apitrace-tests/thirdparty/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 0xb52d
cmpl $0x40002, %ebp # imm = 0x40002
jne 0xb5c2
leaq 0x34d9e(%rip), %rax # 0x40210
movq 0x3f0(%rax), %r14
testq %r14, %r14
je 0xb4ed
leaq ... | /apitrace[P]apitrace-tests/thirdparty/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 0xb81a
testl %eax, %eax
je 0xb809
movslq 0xa0(%r14), %rcx
testq %rcx, %rcx
jle 0xb809
movq 0x98(%r14), %rdx
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edi
movl 0x10(%rbx), %r8d
movl (%rbx), %eax
movl %eax, 0x4(... | /apitrace[P]apitrace-tests/thirdparty/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 0xb8fe
incl (%rdx)
cmpl $0x2, %ea... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c |
glfwGetMonitors | GLFWAPI GLFWmonitor** glfwGetMonitors(int* count)
{
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
*count = _glfw.monitorCount;
return (GLFWmonitor**) _glfw.monitors;
} | pushq %rbx
testq %rdi, %rdi
je 0xb944
movl $0x0, (%rdi)
leaq 0x348f7(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xb92f
movl 0x400(%rax), %ecx
movl %ecx, (%rdi)
movq 0x3f8(%rax), %rbx
jmp 0xb93f
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x8b57
movq %rbx, %rax
... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c |
glfwGetMonitorPhysicalSize | GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int* heightMM)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (widthMM)
*widthMM = 0;
if (heightMM)
*heightMM = 0;
_GLFW_REQUIRE_INIT();
if (widthMM)
*widthMM = mo... | testq %rdi, %rdi
je 0xbab9
testq %rsi, %rsi
je 0xba79
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0xba84
movl $0x0, (%rdx)
leaq 0x34785(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xbaab
testq %rsi, %rsi
je 0xba9d
movl 0x88(%rdi), %eax
movl %eax, (%rsi)
testq %rdx, %rdx
je 0xbaaa
movl 0x8c(%rdi), %eax
movl %eax, (%rdx)
re... | /apitrace[P]apitrace-tests/thirdparty/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 0xbca5
movq %rsi, %r14
testq %rsi, %rsi
je 0xbcc4
movl $0x0, (%r14)
leaq 0x345ad(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xbc86
movq %rdi, %rbx
callq 0xb81a
testl %eax, %eax
je 0xbc98
movl 0xa0(%rbx), %eax
movl %eax, (%r14)
movq 0x98(%rbx), %rbx
jmp 0xbc9a
xor... | /apitrace[P]apitrace-tests/thirdparty/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 0xc000
movq %rsi, %rbx
testq %rsi, %rsi
je 0xc01f
cmpl $0x0, 0x18(%rbx)
je 0xc03e
cmpq $0x0, (%rbx)
je 0xc05d
cmpq $0x0, 0x8(%rbx)
je 0xc07c
cmpq $0x0, 0x10(%rbx)
je 0xc09b
leaq 0x34263(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xbfe3
movq %rdi, %r14
cmpl $0x0, ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/monitor.c |
glfwInitVulkan | GLFWbool _glfwInitVulkan(int mode)
{
VkResult err;
VkExtensionProperties* ep;
uint32_t i, count;
if (_glfw.vk.available)
return GLFW_TRUE;
#if !defined(_GLFW_VULKAN_STATIC)
#if defined(_GLFW_VULKAN_LIBRARY)
_glfw.vk.handle = _glfw_dlopen(_GLFW_VULKAN_LIBRARY);
#elif defined(_GLFW_WIN32)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x34142(%rip), %rbx # 0x40210
movl $0x1, %r14d
cmpl $0x0, 0x205f0(%rbx)
je 0xc0ef
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %ebp
leaq 0x2878c(%rip), %rdi # 0x34884... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/vulkan.c |
glfwGetVulkanResultString | const char* _glfwGetVulkanResultString(VkResult result)
{
switch (result)
{
case VK_SUCCESS:
return "Success";
case VK_NOT_READY:
return "A fence or query has not yet completed";
case VK_TIMEOUT:
return "A wait operation has not completed in the specif... | cmpl $0xc46535ff, %edi # imm = 0xC46535FF
jle 0xc320
leal 0xb(%rdi), %eax
cmpl $0x10, %eax
ja 0xc358
leaq 0x28531(%rip), %rcx # 0x34840
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2896a(%rip), %rax # 0x34c89
retq
cmpl $0xc4653213, %edi # imm = 0xC4653213
jg 0xc340
cmpl $0xc4650b07, ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/vulkan.c |
glfwWindowHint | GLFWAPI void glfwWindowHint(int hint, int value)
{
_GLFW_REQUIRE_INIT();
switch (hint)
{
case GLFW_RED_BITS:
_glfw.hints.framebuffer.redBits = value;
return;
case GLFW_GREEN_BITS:
_glfw.hints.framebuffer.greenBits = value;
return;
case... | leaq 0x335dd(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xcc61
movl %edi, %edx
cmpl $0x22000, %edi # imm = 0x22000
jg 0xcc6f
leal -0x21001(%rdx), %ecx
cmpl $0xf, %ecx
ja 0xcc91
leaq 0x284fc(%rip), %rdx # 0x35150
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl %esi, 0x18(%rax)
retq
movl $0x10... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwSetWindowIcon | GLFWAPI void glfwSetWindowIcon(GLFWwindow* handle,
int count, const GLFWimage* images)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(count >= 0);
assert(count == 0 || images != NULL);
_GLFW_REQUIRE_INIT();
_glfwPlatformSetWindowIcon... | pushq %rax
testq %rdi, %rdi
je 0xcfe9
testl %esi, %esi
js 0xd008
sete %al
testq %rdx, %rdx
setne %cl
orb %al, %cl
je 0xd027
leaq 0x33241(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xcfda
popq %rax
jmp 0x1217e
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x8b57
leaq 0xc3... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwSetWindowPos | GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformSetWindowPos(window, xpos, ypos);
} | testq %rdi, %rdi
je 0xd0cb
leaq 0x33164(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd0bd
cmpq $0x0, 0x48(%rdi)
je 0x12343
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x8b57
pushq %rax
leaq 0xc306(%rip), %rdi # 0x193d9
leaq 0x28178(%rip), %rsi # 0x35252
leaq 0x283f... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwGetWindowSize | GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetWindowSize(window, width, height);
} | testq %rdi, %rdi
je 0xd125
testq %rsi, %rsi
je 0xd0fb
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0xd106
movl $0x0, (%rdx)
leaq 0x33103(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd117
jmp 0x1244a
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x8b57
pushq %rax
leaq 0xc2ac(%rip), %rdi ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwSetWindowSize | GLFWAPI void glfwSetWindowSize(GLFWwindow* handle, int width, int height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(width >= 0);
assert(height >= 0);
_GLFW_REQUIRE_INIT();
window->videoMode.width = width;
window->videoMode.height = height;
_glfwPla... | pushq %rax
testq %rdi, %rdi
je 0xd17a
testl %esi, %esi
js 0xd199
testl %edx, %edx
js 0xd1b8
leaq 0x330b6(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd16b
movl %esi, 0x2c(%rdi)
movl %edx, 0x30(%rdi)
popq %rax
jmp 0x1249c
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x8b... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwSetWindowSizeLimits | GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* handle,
int minwidth, int minheight,
int maxwidth, int maxheight)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (minwidth != GLFW... | testq %rdi, %rdi
je 0xd28c
movl %edx, %eax
movl %esi, %edx
leaq 0x33025(%rip), %rsi # 0x40210
cmpl $0x0, (%rsi)
je 0xd247
cmpl $-0x1, %edx
sete %sil
cmpl $-0x1, %eax
sete %r9b
orb %sil, %r9b
movl %eax, %esi
orl %edx, %esi
setns %sil
orb %r9b, %sil
je 0xd255
cmpl $-0x1, %ecx
sete %sil
cmpl $-0x1, %r8d
sete %r9b
orb ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwSetWindowAspectRatio | GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* handle, int numer, int denom)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(numer != 0);
assert(denom != 0);
_GLFW_REQUIRE_INIT();
if (numer != GLFW_DONT_CARE && denom != GLFW_DONT_CARE)
{
if (numer <... | pushq %rax
testq %rdi, %rdi
je 0xd33b
movl %edx, %ecx
movl %esi, %edx
testl %esi, %esi
je 0xd35a
testl %ecx, %ecx
je 0xd379
leaq 0x32f3f(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd31c
cmpl $-0x1, %edx
sete %al
cmpl $-0x1, %ecx
sete %sil
orb %al, %sil
jne 0xd30d
testl %edx, %edx
setg %al
testl %ecx, %ecx
setg %si... | /apitrace[P]apitrace-tests/thirdparty/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 0xd3d2
testq %rsi, %rsi
je 0xd3a8
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0xd3b3
movl $0x0, (%rdx)
leaq 0x32e56(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd3c4
jmp 0x126b0
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x8b57
pushq %rax
leaq 0xbfff(%rip), %rdi ... | /apitrace[P]apitrace-tests/thirdparty/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 0xd443
testq %rsi, %rsi
je 0xd402
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0xd40d
movl $0x0, (%rdx)
testq %rcx, %rcx
je 0xd418
movl $0x0, (%rcx)
testq %r8, %r8
je 0xd424
movl $0x0, (%r8)
leaq 0x32de5(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd435
jmp 0x126b5
movl $0x10001, %edi # imm = ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwGetWindowContentScale | GLFWAPI void glfwGetWindowContentScale(GLFWwindow* handle,
float* xscale, float* yscale)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (xscale)
*xscale = 0.f;
if (yscale)
*yscale = 0.f;
_GLFW_REQUIRE_INIT();
_gl... | testq %rdi, %rdi
je 0xd49d
testq %rsi, %rsi
je 0xd473
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0xd47e
movl $0x0, (%rdx)
leaq 0x32d8b(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd48f
jmp 0x12902
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x8b57
pushq %rax
leaq 0xbf34(%rip), %rdi ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwMaximizeWindow | GLFWAPI void glfwMaximizeWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformMaximizeWindow(window);
} | testq %rdi, %rdi
je 0xd6a5
leaq 0x32b8a(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd697
cmpq $0x0, 0x48(%rdi)
je 0x12b45
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x8b57
pushq %rax
leaq 0xbd2c(%rip), %rdi # 0x193d9
leaq 0x27b9e(%rip), %rsi # 0x35252
leaq 0x2814... | /apitrace[P]apitrace-tests/thirdparty/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 0xd709
leaq 0x32b3e(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd6e3
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0xd6f2
popq %rbx
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rbx
jmp 0x8b57
movq %rbx, %rdi
callq 0x11b1e
cmpl $0x0, 0x18(%rbx)
je... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwGetWindowAttrib | GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (attrib)
{
case GLFW_FOCUSED:
return _glfwPlatformWindowFocused(window);
case GLFW_ICONIFIED:
... | pushq %rbx
testq %rdi, %rdi
je 0xd91e
leaq 0x32a04(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xd841
movl %esi, %edx
leal -0x20001(%rdx), %eax
cmpl $0xb, %eax
jbe 0xd855
leal -0x22001(%rdx), %eax
cmpl $0xa, %eax
ja 0xd86b
leaq 0x279c0(%rip), %rcx # 0x351f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
m... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwSetWindowAttrib | GLFWAPI void glfwSetWindowAttrib(GLFWwindow* handle, int attrib, int value)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
value = value ? GLFW_TRUE : GLFW_FALSE;
if (attrib == GLFW_AUTO_ICONIFY)
window->autoIconify = value;
else if (attri... | testq %rdi, %rdi
je 0xd9e1
leaq 0x328c3(%rip), %rcx # 0x40210
cmpl $0x0, (%rcx)
je 0xd98d
movl %esi, %eax
xorl %esi, %esi
testl %edx, %edx
setne %dl
leal -0x20003(%rax), %ecx
cmpl $0x9, %ecx
ja 0xd99b
movb %dl, %sil
leaq 0x278ac(%rip), %rdx # 0x3521c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl %e... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwSetWindowMonitor | GLFWAPI void glfwSetWindowMonitor(GLFWwindow* wh,
GLFWmonitor* mh,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
_GLFWwindow* window = (_GLFWwindow*) wh;
_GLFWm... | pushq %rax
testq %rdi, %rdi
je 0xdae1
testl %r8d, %r8d
js 0xdb00
testl %r9d, %r9d
js 0xdb1f
leaq 0x327a0(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xdaa2
testl %r8d, %r8d
setne %al
testl %r9d, %r9d
setne %r10b
testb %r10b, %al
jne 0xdab1
leaq 0x27896(%rip), %rsi # 0x35324
movl $0x10004, %edi # imm = 0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwWaitEventsTimeout | GLFWAPI void glfwWaitEventsTimeout(double timeout)
{
_GLFW_REQUIRE_INIT();
assert(timeout == timeout);
assert(timeout >= 0.0);
assert(timeout <= DBL_MAX);
if (timeout != timeout || timeout < 0.0 || timeout > DBL_MAX)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", timeout);
... | pushq %rax
leaq 0x322f8(%rip), %rax # 0x40210
cmpl $0x0, (%rax)
je 0xdf59
ucomisd %xmm0, %xmm0
jp 0xdf6e
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xdf8d
movsd 0xb8cb(%rip), %xmm1 # 0x19800
ucomisd %xmm0, %xmm1
jb 0xdfac
ucomisd 0xb8bd(%rip), %xmm0 # 0x19800
jbe 0xdf68
leaq 0x2646c(%rip), %rsi # 0x343b... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/window.c |
glfwCreateCursorX11 | Cursor _glfwCreateCursorX11(const GLFWimage* image, int xhot, int yhot)
{
int i;
Cursor cursor;
if (!_glfw.x11.xcursor.handle)
return None;
XcursorImage* native = XcursorImageCreate(image->width, image->height);
if (native == NULL)
return None;
native->xhot = xhot;
native-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x32167(%rip), %r12 # 0x40210
cmpq $0x0, 0x214d8(%r12)
je 0xe18f
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %esi
callq *0x214e0(%r12)
testq %rax, %rax
je 0xe18f
movq %rax, %r14
movl %r15d, 0x10(%rax)
movl %ebp, 0x14(... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_init.c |
glfwPlatformInit | int _glfwPlatformInit(void)
{
// HACK: If the application has left the locale as "C" then both wide
// character text input and explicit UTF-8 input via XIM will break
// This sets the CTYPE part of the current locale from the environment
// in the hope that it is set to something more... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x458, %rsp # imm = 0x458
xorl %edi, %edi
xorl %esi, %esi
callq 0x7520
leaq 0x286c9(%rip), %rsi # 0x36884
movq %rax, %rdi
callq 0x7770
testl %eax, %eax
jne 0xe1d5
leaq 0x2612f(%rip), %rsi # 0x342fd
xorl %edi, %edi
callq 0x7520
ca... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_init.c |
glfwPlatformTerminate | void _glfwPlatformTerminate(void)
{
if (_glfw.x11.helperWindowHandle)
{
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.CLIPBOARD) ==
_glfw.x11.helperWindowHandle)
{
_glfwPushSelectionToManagerX11();
}
XDestroyWindow(_glfw.x11.display, _glfw.x11.helpe... | pushq %rbx
leaq 0x3048e(%rip), %rbx # 0x40210
cmpq $0x0, 0x20660(%rbx)
je 0xfdcb
movq 0x20640(%rbx), %rdi
movq 0x21390(%rbx), %rsi
callq 0x7aa0
cmpq 0x20660(%rbx), %rax
jne 0xfdad
callq 0x10fc0
movq 0x20640(%rbx), %rdi
movq 0x20660(%rbx), %rsi
callq 0x7920
movq $0x0, 0x20660(%rbx)
movq 0x20668(%rbx), %rsi
testq %rs... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_init.c |
glfwPlatformGetVersionString | const char* _glfwPlatformGetVersionString(void)
{
return _GLFW_VERSION_NUMBER " X11 GLX EGL OSMesa"
#if defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
" clock_gettime"
#else
" gettimeofday"
#endif
#if defined(__linux__)
" evdev"
#endif
#if defined(_GLFW_BUILD_DLL)
" shared... | leaq 0x262dc(%rip), %rax # 0x36217
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_init.c |
glfwSetVideoModeX11 | void _glfwSetVideoModeX11(_GLFWmonitor* monitor, const GLFWvidmode* desired)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
GLFWvidmode current;
RRMode native = None;
const GLFWvidmode* best = _glfwChooseVideoMode(monitor, desired);
_glfwPlatformGetVideoMod... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x2ff48(%rip), %r12 # 0x40210
cmpl $0x0, 0x213d8(%r12)
je 0x10481
cmpl $0x0, 0x213fc(%r12)
jne 0x10481
movq %rdi, %r13
callq 0xb6ec
movq %rax, %r14
leaq 0x30(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x10490
movq %rbx, %... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
glfwPlatformGetVideoMode | void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0x2fd69(%rip), %r13 # 0x40210
cmpl $0x0, 0x213d8(%r13)
je 0x10567
cmpl $0x0, 0x213fc(%r13)
jne 0x10567
movq %rdi, %r15
movq 0x20640(%r13), %rdi
movq 0x20650(%r13), %rsi
callq *0x21450(%r13)
movq %rax, %r14
movq 0x20640(%r13... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
vidmodeFromModeInfo | static GLFWvidmode vidmodeFromModeInfo(const XRRModeInfo* mi,
const XRRCrtcInfo* ci)
{
GLFWvidmode mode;
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
mode.width = mi->height;
mode.height = mi->width;
}
else
{
... | pushq %rbx
movq %rdi, %rbx
movzwl 0x20(%rdx), %eax
cmpl $0x8, %eax
je 0x105cb
cmpl $0x2, %eax
jne 0x105d6
movl 0xc(%rsi), %eax
movl %eax, (%rbx)
leaq 0x8(%rsi), %rax
jmp 0x105df
movl 0x8(%rsi), %eax
movl %eax, (%rbx)
leaq 0xc(%rsi), %rax
movl (%rax), %eax
movl %eax, 0x4(%rbx)
movl 0x20(%rsi), %eax
xorl %edx, %edx
testl... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
glfwRestoreVideoModeX11 | void _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
if (monitor->x11.oldMode == None)
return;
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcIn... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2fb8b(%rip), %r12 # 0x40210
cmpl $0x0, 0x213d8(%r12)
je 0x1074a
cmpl $0x0, 0x213fc(%r12)
jne 0x1074a
movq %rdi, %rbx
cmpq $0x0, 0x110(%rdi)
je 0x1074a
movq 0x20640(%r12), %rdi
movq 0x20650(%r12), %rsi
callq *0x21450(%r12)
movq %rax, %r14
movq 0x20640(%r1... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
glfwPlatformGetMonitorPos | void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.displ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x2faa9(%rip), %rax # 0x40210
cmpl $0x0, 0x213d8(%rax)
je 0x107fa
cmpl $0x0, 0x213fc(%rax)
jne 0x107fa
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x20640(%rax), %rdi
movq 0x20650(%rax), %rsi
movq %rax, %r13
callq *0x21450(%rax)
movq %rax, %r15
mo... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
glfwPlatformGetVideoModes | GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
{
GLFWvidmode* result;
*count = 0;
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movl $0x0, (%rsi)
leaq 0x2f73e(%rip), %r14 # 0x40210
cmpl $0x0, 0x213d8(%r14)
je 0x10c3a
cmpl $0x0, 0x213fc(%r14)
jne 0x10c3a
movq 0x20640(%r14), %rdi
movq 0x20650(%r14), %rsi
callq *0x21450(%r14)
movq... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
glfwPlatformGetGammaRamp | GLFWbool _glfwPlatformGetGammaRamp(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
const size_t size = XRRGetCrtcGammaSize(_glfw.x11.display,
monitor->x11.crtc);
XRRCrtcGamma* gamma = X... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x2f58f(%rip), %r12 # 0x40210
cmpl $0x0, 0x213d8(%r12)
je 0x10d20
cmpl $0x0, 0x213f8(%r12)
jne 0x10d20
movq %rdi, %r15
movq 0x20640(%r12), %rdi
movq 0x108(%r15), %rsi
callq *0x21430(%r12)
movslq %eax, %r14
movq 0x20640(%r12), %rdi
movq 0x10... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_monitor.c |
glfwGetWindowPropertyX11 | unsigned long _glfwGetWindowPropertyX11(Window window,
Atom property,
Atom type,
unsigned char** value)
{
Atom actualType;
int actualFormat;
unsigned long itemCount, bytesAfter;
XGetW... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rax
movq %rdx, %r10
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x2f2d0(%rip), %rcx # 0x40210
movq 0x20640(%rcx), %rdi
leaq 0x8(%rsp), %r11
leaq 0x10(%rsp), %rbx
leaq 0x4(%rsp), %r14
leaq 0x18(%rsp), %r15
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFF... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
handleSelectionRequest | static void handleSelectionRequest(XEvent* event)
{
const XSelectionRequestEvent* request = &event->xselectionrequest;
XEvent reply = { SelectionNotify };
reply.xselection.property = writeTargetToProperty(request);
reply.xselection.display = request->display;
reply.xselection.requestor = request->r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbp
leaq 0x78(%rsp), %r14
xorl %ebx, %ebx
movl $0xc0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x72f0
movl $0x1f, (%r14)
leaq 0x2f134(%rip), %r13 # 0x40210
movq 0x213b8(%r13), %rax
movq %rax, 0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
handleSelectionClear | static void handleSelectionClear(XEvent* event)
{
if (event->xselectionclear.selection == _glfw.x11.PRIMARY)
{
free(_glfw.x11.primarySelectionString);
_glfw.x11.primarySelectionString = NULL;
}
else
{
free(_glfw.x11.clipboardString);
_glfw.x11.clipboardString = NULL;
... | pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
leaq 0x2ee70(%rip), %rbx # 0x40210
xorl %r14d, %r14d
cmpq 0x21398(%rbx), %rax
setne %r14b
movq 0x20688(%rbx,%r14,8), %rdi
callq 0x76c0
movq $0x0, 0x20688(%rbx,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
updateWindowMode | static void updateWindowMode(_GLFWwindow* window)
{
if (window->monitor)
{
if (_glfw.x11.xinerama.available &&
_glfw.x11.NET_WM_FULLSCREEN_MONITORS)
{
sendEventToWM(window,
_glfw.x11.NET_WM_FULLSCREEN_MONITORS,
window->m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
leaq 0x2e673(%rip), %r12 # 0x40210
cmpl $0x0, 0x214f8(%r12)
setne %dl
movq 0x212e0(%r12), %r14
testq %r14, %r14
setne %cl
andb %dl, %cl
testq %rax, %rax
je 0x11cce
testb %cl, %cl
je 0x11c36
movsl... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
acquireMonitor | static void acquireMonitor(_GLFWwindow* window)
{
if (_glfw.x11.saver.count == 0)
{
// Remember old screen saver settings
XGetScreenSaver(_glfw.x11.display,
&_glfw.x11.saver.timeout,
&_glfw.x11.saver.interval,
&_glfw.x11.sav... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x2e3a1(%rip), %r13 # 0x40210
cmpl $0x0, 0x214a8(%r13)
jne 0x11eb9
movq 0x20640(%r13), %rdi
leaq 0x214ac(%r13), %rsi
leaq 0x214b0(%r13), %rdx
leaq 0x214b4(%r13), %rcx
leaq 0x214b8(%r13), %r8
callq 0x7160
movq 0x20640(%r13),... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
releaseMonitor | static void releaseMonitor(_GLFWwindow* window)
{
if (window->monitor->window != window)
return;
_glfwInputMonitorWindow(window->monitor, NULL);
_glfwRestoreVideoModeX11(window->monitor);
_glfw.x11.saver.count--;
if (_glfw.x11.saver.count == 0)
{
// Restore old screen saver se... | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
cmpq %rbx, 0x90(%rdi)
jne 0x12058
xorl %esi, %esi
callq 0xb637
movq 0x48(%rbx), %rdi
callq 0x10676
leaq 0x2e1c0(%rip), %rax # 0x40210
decl 0x214a8(%rax)
je 0x1205a
popq %rbx
retq
movq 0x20640(%rax), %rdi
movl 0x214ac(%rax), %esi
movl 0x214b0(%rax), %edx
movl 0x214b4(... | /apitrace[P]apitrace-tests/thirdparty/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 0x2e178(%rip), %r15 # 0x40210
movq 0x20640(%r15), %rdi
movq 0x350(%r14), %rsi
subq $0x20, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, %rdx
movq %rbx, %rcx
xorl %r8d, %r... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetWindowIcon | void _glfwPlatformSetWindowIcon(_GLFWwindow* window,
int count, const GLFWimage* images)
{
if (count)
{
int i, j, longCount = 0;
for (i = 0; i < count; i++)
longCount += 2 + images[i].width * images[i].height;
unsigned long* icon = calloc(l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x121c2
movq %rdx, %r14
movl %esi, %ebp
movl %esi, %r13d
jle 0x121e8
movq %r13, %rax
shlq $0x4, %rax
xorl %ecx, %ecx
xorl %r12d, %r12d
movl 0x4(%r14,%rcx), %edx
imull (%r14,%rcx), %edx
addl %edx, %r12d
addl ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetWindowSize | void _glfwPlatformGetWindowSize(_GLFWwindow* window, int* width, int* height)
{
XWindowAttributes attribs;
XGetWindowAttributes(_glfw.x11.display, window->x11.handle, &attribs);
if (width)
*width = attribs.width;
if (height)
*height = attribs.height;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x2ddaf(%rip), %rax # 0x40210
movq 0x20640(%rax), %rax
movq 0x350(%rdi), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x7a70
testq %r14, %r14
je 0x12486
movl 0x8(%rsp), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x12491
movl 0xc(%rsp), %eax
m... | /apitrace[P]apitrace-tests/thirdparty/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 0x48(%rdi), %rax
testq %rax, %rax
je 0x124bf
cmpq %r14, 0x90(%rax)
jne 0x124f4
movq %r14, %rdi
callq 0x11e58
jmp 0x124f4
movl %edx, %ebx
movl %esi, %ebp
cmpl $0x0, 0x8(%r14)
jne 0x124d6
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1250b
leaq 0x2dd33(%rip)... | /apitrace[P]apitrace-tests/thirdparty/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 0x70c0
movq %rax, %rbx
cmpq $0x0, 0x48(%r14)
jne 0x125c2
cmpl $0x0, 0x8(%r14)
je 0x12598
movl 0x58(%r14), %eax
cmpl $-0x1, %eax
je 0x1254f
movl 0x5c(%r14), %ecx
cmpl $-0x1, %ecx
je 0x1254f
orb $0x10, (%rbx)
mov... | /apitrace[P]apitrace-tests/thirdparty/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 0x2dbfe(%rip), %r15 # 0x40210
movq 0x20640(%r15), %rdi
movq 0x350(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x7a70
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
movq %rbx, %rdi
callq 0x1250b
movq 0x20640(%r15), %rdi
callq 0x78d0
addq $0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetWindowFrameSize | void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
int* left, int* top,
int* right, int* bottom)
{
long* extents = NULL;
if (window->monitor || !window->decorated)
return;
if (_glfw.x11.NET_FRAME_EXTENTS == None)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x48(%rdi)
je 0x126e8
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbp
cmpl $0x0, 0xc(%rdi)
je 0x126d6
l... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
isFrameExtentsEvent | static Bool isFrameExtentsEvent(Display* display, XEvent* event, XPointer pointer)
{
_GLFWwindow* window = (_GLFWwindow*) pointer;
return event->type == PropertyNotify &&
event->xproperty.state == PropertyNewValue &&
event->xproperty.window == window->x11.handle &&
event->xprope... | xorl %eax, %eax
cmpl $0x1c, (%rsi)
jne 0x128dc
cmpl $0x0, 0x38(%rsi)
je 0x128dd
retq
movq 0x20(%rsi), %rcx
cmpq 0x350(%rdx), %rcx
jne 0x128dc
movq 0x28(%rsi), %rcx
leaq 0x2d91b(%rip), %rdx # 0x40210
xorl %eax, %eax
cmpq 0x21310(%rdx), %rcx
sete %al
retq
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformIconifyWindow | void _glfwPlatformIconifyWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification ... | cmpl $0x0, 0x368(%rdi)
je 0x1294f
leaq 0x243c6(%rip), %rsi # 0x36d09
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x8b57
pushq %rbx
leaq 0x2d8b9(%rip), %rbx # 0x40210
movq 0x20640(%rbx), %rax
movq 0x350(%rdi), %rsi
movl 0x20648(%rbx), %edx
movq %rax, %rdi
callq 0x72c0
movq 0x20640(%rbx), %rd... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformRestoreWindow | void _glfwPlatformRestoreWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification ... | cmpl $0x0, 0x368(%rdi)
je 0x1299c
leaq 0x24379(%rip), %rsi # 0x36d09
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x8b57
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
callq 0x1332b
cmpl $0x3, %eax
jne 0x129e1
leaq 0x2d84f(%rip), %rax # 0x4... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
waitForVisibilityNotify | static GLFWbool waitForVisibilityNotify(_GLFWwindow* window)
{
XEvent dummy;
double timeout = 0.1;
while (!XCheckTypedWindowEvent(_glfw.x11.display,
window->x11.handle,
VisibilityNotify,
&dummy))
{
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x2d70b(%rip), %r12 # 0x40210
leaq 0x8(%rsp), %r15
movq 0x20640(%r12), %rdi
movq 0x350(%rbx), %rsi
movl $0xf, %edx
movq %r15, %rcx
callq 0x... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformRequestWindowAttention | void _glfwPlatformRequestWindowAttention(_GLFWwindow* window)
{
if (!_glfw.x11.NET_WM_STATE || !_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTION)
return;
sendEventToWM(window,
_glfw.x11.NET_WM_STATE,
_NET_WM_STATE_ADD,
_glfw.x11.NET_WM_STATE_DEMANDS_ATTENTI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
leaq 0x2d496(%rip), %r15 # 0x40210
movq 0x212a8(%r15), %r13
movq 0x212d0(%r15), %r12
testq %r13, %r13
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x12e06
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
xorl %ebp, %ebp
... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetWindowMonitor | void _glfwPlatformSetWindowMonitor(_GLFWwindow* window,
_GLFWmonitor* monitor,
int xpos, int ypos,
int width, int height,
int refreshRate)
{
if (window->monitor == monitor)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq %rsi, %rax
je 0x12fd2
testq %rax, %rax
je 0x12f5f
movl 0xc(%rbx), %esi
movq %rbx, %rdi
callq 0x1304a
movl 0x14(... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetWindowDecorated | void _glfwPlatformSetWindowDecorated(_GLFWwindow* window, GLFWbool enabled)
{
struct
{
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long input_mode;
unsigned long status;
} hints = {0};
hints.flags = MWM_HINTS_DECORATIONS;
hints.de... | subq $0x28, %rsp
xorps %xmm0, %xmm0
movq %rsp, %r10
movaps %xmm0, (%r10)
movaps %xmm0, 0x10(%r10)
movq $0x0, 0x20(%r10)
movq $0x2, (%r10)
xorl %eax, %eax
testl %esi, %esi
setne %al
movq %rax, 0x10(%r10)
leaq 0x2d192(%rip), %rcx # 0x40210
movq 0x20640(%rcx), %rax
movq 0x350(%rdi), %rsi
movq 0x21320(%rcx), %rcx
movq ... | /apitrace[P]apitrace-tests/thirdparty/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 long 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 0x2d148(%rip), %r15 # 0x40210
cmpq $0x0, 0x212a8(%r15)
je 0x132d8
cmpq $0x0, 0x212b0(%r15)
je 0x132d8
movl %esi, %ebp
movq %rdi, %rbx
movq 0x20640(%r15), %rdi
movq 0x350(%rbx), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdx
callq 0x... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
getWindowState | static int getWindowState(_GLFWwindow* window)
{
int result = WithdrawnState;
struct {
CARD32 state;
Window icon;
} *state = NULL;
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.WM_STATE,
_glfw.x11.WM_STATE... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x350(%rdi), %rsi
leaq 0x2cec2(%rip), %rcx # 0x40210
movq 0x21260(%rcx), %rdx
movq 0x20640(%rcx), %rdi
leaq 0x18(%rsp), %r10
leaq 0x20(%rsp), %r14
leaq 0x14(%rsp), %r11
leaq 0x28(%rsp), %r15
xorl %ebx, %ebx
movabsq $0x7fff... | /apitrace[P]apitrace-tests/thirdparty/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 0x2ce42(%rip), %r14 # 0x40210
movq 0x212a8(%r14), %rdx
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x1348d
cmpq $0x0, 0x212c0(%r14)
je 0x1348d
cmpq $0x0, 0x212c8(%r14)
je 0x1348d
movq 0x350(%rdi), %rsi
movq 0x20640(%r14), %rdi
movq %rsp, %rax
leaq 0x10(%rsp)... | /apitrace[P]apitrace-tests/thirdparty/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;
_glfwGrabErrorHandlerX11();
const Bool result = XQueryPointer(_glfw.x11.display, w,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x2cd5b(%rip), %rbp # 0x40210
movq 0x20650(%rbp), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
leaq 0x30(%rsp), %r15
leaq 0x2c(%rsp), %r12
leaq 0x28(%rsp), %r13
cmpq $0x0, 0x8(%rsp)
je 0x13572
callq 0xdfec
m... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetRawMouseMotion | void _glfwPlatformSetRawMouseMotion(_GLFWwindow *window, GLFWbool enabled)
{
if (!_glfw.x11.xi.available)
return;
if (_glfw.x11.disabledCursorWindow != window)
return;
if (enabled)
enableRawMouseMotion(window);
else
disableRawMouseMotion(window);
} | subq $0x18, %rsp
leaq 0x2cace(%rip), %rax # 0x40210
cmpl $0x0, 0x21570(%rax)
je 0x137b0
cmpq %rdi, 0x21238(%rax)
jne 0x137b0
leaq 0x4(%rsp), %rcx
testl %esi, %esi
je 0x1377e
movw $0x0, (%rcx)
movabsq $0x300000001, %rsi # imm = 0x300000001
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq %rcx, 0x8(%rdx)
movb $0x2, 0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformPollEvents | void _glfwPlatformPollEvents(void)
{
drainEmptyEvents();
#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 $0x1d8, %rsp # imm = 0x1D8
leaq 0x2ca35(%rip), %rbp # 0x40210
leaq 0x110(%rsp), %rbx
movl 0x21240(%rbp), %edi
movl $0x40, %edx
movq %rbx, %rsi
callq 0x77d0
cmpl $-0x1, %eax
jne 0x137e3
callq 0x7050
cmpl $0x4, (%rax)
je 0x137e3
callq 0... | /apitrace[P]apitrace-tests/thirdparty/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
cvttsd2si %xmm0, %r10d
movl %r10d, 0x390(%rdi)
cvttsd2si %xmm1, %r11d
movl %r11d, 0x394(%rdi)
leaq 0x2b978(%rip), %rbx # 0x40210
movq 0x20640(%rbx), %rax
movq 0x350(%rdi), %rdx
subq $0x8, %rsp
movq %rax, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r11
pushq %r10
pushq $0x0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
waitForAnyEvent | static GLFWbool waitForAnyEvent(double* timeout)
{
nfds_t count = 2;
struct pollfd fds[3] =
{
{ ConnectionNumber(_glfw.x11.display), POLLIN },
{ _glfw.x11.emptyEventPipe[0], POLLIN }
};
#if defined(__linux__)
if (_glfw.linjs.inotify > 0)
fds[count++] = (struct pollfd) { _glf... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x2b918(%rip), %r12 # 0x40210
movq 0x20640(%r12), %rax
movl 0x10(%rax), %eax
movl %eax, (%rsp)
movl $0x1, %eax
movl %eax, 0x4(%rsp)
movl 0x21240(%r12), %ecx
movl %ecx, 0x8(%rsp)
movl %eax, 0xc(%rsp)
movq $0x0, 0x10(%rsp)
mo... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformGetCursorPos | void _glfwPlatformGetCursorPos(_GLFWwindow* window, double* xpos, double* ypos)
{
Window root, child;
int rootX, rootY, childX, childY;
unsigned int mask;
XQueryPointer(_glfw.x11.display, window->x11.handle,
&root, &child,
&rootX, &rootY, &childX, &childY,
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x2b7f5(%rip), %rax # 0x40210
movq 0x20640(%rax), %rax
movq 0x350(%rdi), %rsi
subq $0x8, %rsp
leaq 0x1c(%rsp), %r10
leaq 0x14(%rsp), %r11
leaq 0x18(%rsp), %r15
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x24(%rsp), %r8
leaq... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
glfwPlatformSetCursorMode | void _glfwPlatformSetCursorMode(_GLFWwindow* window, int mode)
{
if (mode == GLFW_CURSOR_DISABLED)
{
if (_glfwPlatformWindowFocused(window))
disableCursor(window);
}
else if (_glfw.x11.disabledCursorWindow == window)
enableCursor(window);
else
updateCursorImage(wi... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x2b771(%rip), %rax # 0x40210
cmpl $0x34003, %esi # imm = 0x34003
jne 0x14ad6
movq 0x20640(%rax), %rdi
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %rdx
movq %r14, %rsi
callq 0x7a20
movq 0x350(%rbx), %rax
cmpq (%r14), %rax
jne 0x14af1
movq %rbx, %rdi
cal... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.c |
disableCursor | static void disableCursor(_GLFWwindow* window)
{
if (window->rawMouseMotion)
enableRawMouseMotion(window);
_glfw.x11.disabledCursorWindow = window;
_glfwPlatformGetCursorPos(window,
&_glfw.x11.restoreCursorPosX,
&_glfw.x11.restoreCursorPos... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x1f8(%rdi)
je 0x14b63
leaq 0x4(%rsp), %rax
movw $0x0, (%rax)
movabsq $0x300000001, %rcx # imm = 0x300000001
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movb $0x2, 0x2(%rax)
leaq 0x2b6c6(%rip), %rax # 0x40210
movq 0x20640(%rax), ... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/x11_window.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.