name string | code string | asm string | file string |
|---|---|---|---|
glfwPlatformCreateTls | GLFWbool _glfwPlatformCreateTls(_GLFWtls* tls)
{
assert(tls->posix.allocated == GLFW_FALSE);
if (pthread_key_create(&tls->posix.key, NULL) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"POSIX: Failed to create context TLS");
return GLFW_FALSE;
}
tls->posix.al... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jne 0x2aeae
movq %rdi, %r14
addq $0x4, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x7890
testl %eax, %eax
je 0x2ae9a
leaq 0x36332(%rip), %rsi # 0x611be
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1eed8
jmp 0x2aea4
movl $0x1, (%r14)
pushq $0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/posix_thread.c |
glfwPlatformCreateMutex | GLFWbool _glfwPlatformCreateMutex(_GLFWmutex* mutex)
{
assert(mutex->posix.allocated == GLFW_FALSE);
if (pthread_mutex_init(&mutex->posix.handle, NULL) != 0)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "POSIX: Failed to create mutex");
return GLFW_FALSE;
}
return mutex->posix.allocated ... | pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, (%rdi)
jne 0x2af7e
movq %rdi, %r14
addq $0x8, %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x77a0
testl %eax, %eax
je 0x2af6a
leaq 0x36350(%rip), %rsi # 0x612ac
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1eed8
jmp 0x2af74
movl $0x1, (%r14)
pushq $0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/posix_thread.c |
glfwInitGLX | GLFWbool _glfwInitGLX(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_GLX_LIBRARY)
_GLFW_GLX_LIBRARY,
#elif defined(__CYGWIN__)
"libGL-1.so",
#elif defined(__OpenBSD__) || defined(__NetBSD__)
"libGL.so",
#else
"libGL.so.1",
"libGL.so",
#endif
NULL
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x45d91(%rip), %r14 # 0x70db8
cmpq $0x0, 0x215f0(%r14)
je 0x2b039
pushq $0x1
popq %rbx
jmp 0x2b31e
xorl %r15d, %r15d
leaq 0x3dcdd(%rip), %r12 # 0x68d20
pushq $0x1
popq %rbx
cmpq $0x10, %r15
je 0x2b2f9
movq (%r15,%r12), %rdi
movl %ebx, %esi
callq 0x76d0... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
getProcAddressGLX | static GLFWglproc getProcAddressGLX(const char* procname)
{
if (_glfw.glx.GetProcAddress)
return _glfw.glx.GetProcAddress((const GLubyte*) procname);
else if (_glfw.glx.GetProcAddressARB)
return _glfw.glx.GetProcAddressARB((const GLubyte*) procname);
else
return _glfw_dlsym(_glfw.glx... | movq %rdi, %rsi
leaq 0x45888(%rip), %rax # 0x70db8
movq 0x21660(%rax), %rcx
testq %rcx, %rcx
jne 0x2b548
movq 0x21668(%rax), %rcx
testq %rcx, %rcx
je 0x2b54d
movq %rsi, %rdi
jmpq *%rcx
movq 0x215f0(%rax), %rdi
jmp 0x7520
| /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
glfwGetGLXContext | GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.source != GLFW_NATIVE_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->cont... | pushq %rbx
leaq 0x44fb7(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x2be1b
cmpl $0x36001, 0x204(%rdi) # imm = 0x36001
jne 0x2be24
movq 0x278(%rdi), %rbx
jmp 0x2be34
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2be2b
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
glfwGetGLXWindow | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (window->context.source != GLFW_NATIVE_CONTEXT_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return None;
}
return window->contex... | pushq %rbx
leaq 0x44f77(%rip), %rax # 0x70db8
cmpl $0x0, (%rax)
je 0x2be5b
cmpl $0x36001, 0x204(%rdi) # imm = 0x36001
jne 0x2be64
movq 0x280(%rdi), %rbx
jmp 0x2be74
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2be6b
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi... | /apitrace[P]apitrace-tests/thirdparty/glfw/src/glx_context.c |
PDCLIB_prepwrite | int _PDCLIB_prepwrite( struct _PDCLIB_file_t * stream )
{
if ( ( stream->bufidx < stream->bufend ) || ( stream->ungetidx > 0 ) ||
( stream->status & ( _PDCLIB_FREAD | _PDCLIB_ERRORFLAG | _PDCLIB_WIDESTREAM | _PDCLIB_EOFFLAG ) ) ||
!( stream->status & ( _PDCLIB_FWRITE | _PDCLIB_FAPPEND | _PDCLIB_FR... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
jb 0x247d
cmpq $0x0, 0x38(%rbx)
jne 0x247d
movl 0x44(%rbx), %eax
testl $0xe08, %eax # imm = 0xE08
sete %cl
testb $0x70, %al
setne %dl
testb %dl, %cl
jne 0x2493
callq 0x3950
movl $0x9, (%rax)
orb $0x2, 0x45(%rbx)
movl $0xffffffff, %eax ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_prepwrite.c |
memmove | void * memmove( void * s1, const void * s2, size_t n )
{
char * dest = ( char * ) s1;
const char * src = ( const char * ) s2;
if ( dest <= src )
{
while ( n-- )
{
*dest++ = *src++;
}
}
else
{
src += n;
dest += n;
while ( n-- )
... | movq %rdi, %rax
cmpq %rsi, %rdi
jbe 0x3938
testq %rdx, %rdx
je 0x394f
movq %rdx, %rcx
movb -0x1(%rsi,%rdx), %dil
movb %dil, -0x1(%rax,%rdx)
decq %rcx
movq %rcx, %rdx
jne 0x3924
jmp 0x394f
testq %rdx, %rdx
je 0x394f
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
movb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x393f
retq
| /DevSolar[P]pdclib/functions/string/memmove.c |
cJSON_InitHooks | CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
{
if (hooks == NULL)
{
/* Reset hooks */
global_hooks.allocate = malloc;
global_hooks.deallocate = free;
global_hooks.reallocate = realloc;
return;
}
global_hooks.allocate = malloc;
if (hooks->malloc_fn !... | testq %rdi, %rdi
je 0x2293
movq 0x5d8b(%rip), %rdx # 0x7fe0
movq %rdx, 0x5e3c(%rip) # 0x8098
movq (%rdi), %rax
testq %rax, %rax
cmoveq %rdx, %rax
movq 0x5d53(%rip), %rsi # 0x7fc0
movq %rsi, 0x5e2c(%rip) # 0x80a0
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
cmoveq %rsi, %rcx
xorq %rax, %rdx
xorq %rcx, %rsi
... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
buffer_skip_whitespace | static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
if ((buffer == NULL) || (buffer->content == NULL))
{
return NULL;
}
while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
{
buffer->offset++;
}
if (buffer->offset == buffer->le... | testq %rdi, %rdi
je 0x294b
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x294b
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
jae 0x293f
cmpb $0x20, (%rdx,%rcx)
ja 0x293f
incq %rcx
movq %rcx, 0x10(%rdi)
cmpq %rcx, %rax
jne 0x292b
jmp 0x2944
cmpq %rax, %rcx
jne 0x294b
decq %rax
movq %rax, 0x10(%rdi)
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
print | static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
{
printbuffer buffer[1];
unsigned char *printed = NULL;
memset(buffer, 0, sizeof(buffer));
/* create buffer */
buffer->buffer = (unsigned char*) hooks->allocate(256);
buffer->format = f... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x100, %edi # imm = 0x100
callq *0x5705(%rip) # 0x8098
movq %rax, (%rsp)
movl %... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_PrintBuffered | CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
{
printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
if (prebuffer < 0)
{
return NULL;
}
p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
if (!p.buffer)
{
return N... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, 0x48(%rsp)
movq $0x0, 0x20(%rsp)
testl %esi, %esi
js 0x2b12
movl %edx, %ebp
movq %rdi, %r14
movl %esi, %ebx
movq %rbx, %rdi
callq *0x55d2(%rip) # 0x8098
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2b12
leaq 0x8(%rsp), %rsi
movq %r... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_AddItemToArray | CJSON_PUBLIC(void) cJSON_AddItemToArray(cJSON *array, cJSON *item)
{
cJSON *child = NULL;
if ((item == NULL) || (array == NULL))
{
return;
}
child = array->child;
if (child == NULL)
{
/* list is empty, start new one */
array->child = item;
}
else
{
... | testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x327b
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x327c
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
jne 0x3269
movq %rsi, (%rcx)
movq %rcx, 0x8(%rsi)
retq
movq %rsi, 0x10(%rdi)
retq
| /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_DetachItemFromObject | CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string)
{
cJSON *to_detach = cJSON_GetObjectItem(object, string);
return cJSON_DetachItemViaPointer(object, to_detach);
} | pushq %rbx
movq %rdi, %rbx
xorl %edx, %edx
callq 0x3159
testq %rbx, %rbx
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x3500
xorl %eax, %eax
jmp 0x3528
movq (%rax), %rcx
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x350f
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x3518
movq %rdx, 0x8(%rcx)
cmpq %rax, 0x10(%rbx)
jne 0x35... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
cJSON_InsertItemInArray | CJSON_PUBLIC(void) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
{
cJSON *after_inserted = NULL;
if (which < 0)
{
return;
}
after_inserted = get_array_item(array, (size_t)which);
if (after_inserted == NULL)
{
cJSON_AddItemToArray(array, newitem);
... | testl %esi, %esi
sets %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x35e1
movl %esi, %ecx
addq $0x10, %rdi
movq %rdi, %rax
movq (%rax), %rax
addq $-0x1, %rcx
setb %sil
testq %rax, %rax
je 0x35c1
testb %sil, %sil
jne 0x35ac
testq %rax, %rax
je 0x35e2
movq %rax, (%rdx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
movq %rd... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
print_string_ptr | static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer)
{
const unsigned char *input_pointer = NULL;
unsigned char *output = NULL;
unsigned char *output_pointer = NULL;
size_t output_length = 0;
/* numbers of additional characters needed for escaping ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
testq %rdi, %rdi
je 0x4bac
movq %rdi, %rbx
xorl %r12d, %r12d
movabsq $0x400003700, %rcx # imm = 0x400003700
xorl %r13d, %r13d
movzbl (%rbx,%r12), %edx
cmpq $0x22, %rdx
ja 0x4ad0
btq %rdx, %rcx
jae 0x4acb
incq %r13
incq %r1... | /icsiii[P]embedded-abstract-message/vendor/cJSON/tests/../cJSON.c |
SM83::ld_a_dde() | void SM83::ld_a_dde() {
LTRACE("LD A, (DE)");
a = bus.Read8(de);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
SM83::ld_a_dhld() | void SM83::ld_a_dhld() {
LTRACE("LD A, (HL-)");
a = bus.Read8(hl--);
} | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
SM83::and_d8() | void SM83::and_d8() {
u8 value = GetByteFromPC();
LTRACE("AND 0x{:02X}", value);
a &= value;
SetZeroFlag(a == 0);
SetNegateFlag(false);
SetHalfCarryFlag(true);
SetCarryFlag(false);
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movzwl 0xa(%rbx), %esi
leal 0x1(%rsi), %eax
movw %ax, 0xa(%rbx)
movl $0x1, %edx
callq 0x443e
movzwl (%rbx), %edx
movq %rsp, %rcx
movq %rdx, (%rcx)
movzwl 0x2(%rbx), %edx
movq %rdx, 0x10(%rcx)
movzwl 0x4(%rbx), %edx
movq %rdx, 0x20(%rcx)
movzwl... | /tgsm[P]heliage/src/sm83.cpp |
SM83::ld_hl_sp_d8() | void SM83::ld_hl_sp_d8() {
s8 value = static_cast<s8>(GetByteFromPC());
LTRACE("LD HL, SP+0x{:02X}", value);
u32 result = sp + value;
SetZeroFlag(false);
SetNegateFlag(false);
SetHalfCarryFlag(((sp ^ value ^ (result & 0xFFFF)) & 0x10) == 0x10);
SetCarryFlag(((sp ^ value ^ (result & 0xFFFF)... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movzwl 0xa(%rbx), %esi
leal 0x1(%rsi), %eax
movw %ax, 0xa(%rbx)
movl $0x1, %edx
callq 0x443e
movzwl (%rbx), %edx
movq %rsp, %rcx
movq %rdx, (%rcx)
movzwl 0x2(%rbx), %edx
movq %rdx, 0x10(%rcx)
movzwl 0x4(%rbx), %edx
movq %rdx, 0x20(%rcx)
movzwl... | /tgsm[P]heliage/src/sm83.cpp |
SM83::rl_dhl() | void SM83::rl_dhl() {
LTRACE("RL (HL)");
u8 value = bus.Read8(hl);
bool carry = HasFlag(Flags::Carry);
bool should_carry = value & (1 << 7);
SetCarryFlag(should_carry);
u8 result = value << 1;
result |= carry;
SetZeroFlag(result == 0);
SetNegateFlag(false);
SetHalfCarryFlag(f... | pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void fmt::v11::print<unsigned short&, unsigned short&, unsigned short&, unsigned short&, unsigned short&, unsigned short&>(fmt::v11::basic_format_string<char, fmt::v11::type_identity<unsigned short&>::type, fmt::v11::type_identity<unsigned short&>::type, fmt::v11::type_identity<unsigned short&>::type, fmt::v11::type_id... | FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
const auto& vargs = fmt::make_format_args(args...);
if (!detail::use_utf8()) return detail::vprint_mojibake(stdout, fmt, vargs);
return detail::is_locking<T...>() ? vprint_buffered(stdout, fmt, vargs)
: vprint(fmt, v... | subq $0x68, %rsp
movq 0x78(%rsp), %r10
movq 0x70(%rsp), %r11
movzwl (%rdx), %edx
movq %rsp, %rax
movq %rdx, (%rax)
movzwl (%rcx), %ecx
movq %rcx, 0x10(%rax)
movzwl (%r8), %ecx
movq %rcx, 0x20(%rax)
movzwl (%r9), %ecx
movq %rcx, 0x30(%rax)
movzwl (%r11), %ecx
movq %rcx, 0x40(%rax)
movzwl (%r10), %ecx
movq %rcx, 0x50(%ra... | /tgsm[P]heliage/dependencies/fmt/include/fmt/base.h |
void SM83::ld_r_r<(SM83::Registers)2, (SM83::Registers)2>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | subq $0x88, %rsp
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rcx)
movl $0x42, %eax
movq %r... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)2, (SM83::Registers)3>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)2, (SM83::Registers)4>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)2, (SM83::Registers)6>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)3, (SM83::Registers)2>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)3, (SM83::Registers)0>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)5, (SM83::Registers)4>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)6, (SM83::Registers)3>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)7, (SM83::Registers)4>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)0, (SM83::Registers)5>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::ld_r_r<(SM83::Registers)0, (SM83::Registers)7>() | void SM83::ld_r_r() {
LTRACE("LD {}, {}", Get8bitRegisterName<DestRegister>(), Get8bitRegisterName<SrcRegister>());
u8* dest = Get8bitRegisterPointer<DestRegister>();
*dest = Get8bitRegister<SrcRegister>();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::jp_a16<(SM83::Conditions)3>() | void SM83::jp_a16() {
const u16 addr = GetWordFromPC();
if constexpr (cond == Conditions::None) {
LTRACE("JP 0x{:04X}", addr);
} else {
LTRACE("JP {}, 0x{:04X}", GetConditionString<cond>(), addr);
}
if (MeetsCondition<cond>()) {
pc = addr;
timer.AdvanceCycles(4);
... | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0xb338
movl %eax, %ebp
movzwl (%rbx), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rbx), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rbx), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rbx), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rbx), %eax
movq %rax, 0x40(%rcx)
mo... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::call_a16<(SM83::Conditions)0>() | void SM83::call_a16() {
const u16 address = GetWordFromPC();
if constexpr (cond == Conditions::None) {
LTRACE("CALL 0x{:04X}", address);
} else {
LTRACE("CALL {}, 0x{:04X}", GetConditionString<cond>(), address);
}
if (MeetsCondition<cond>()) {
StackPush(pc);
pc = ad... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0xb338
movzwl (%rbx), %edx
movq %rsp, %rcx
movq %rdx, (%rcx)
movzwl 0x2(%rbx), %edx
movq %rdx, 0x10(%rcx)
movzwl 0x4(%rbx), %edx
movq %rdx, 0x20(%rcx)
movzwl 0x6(%rbx), %edx
movq %rdx, 0x30(%rcx)
movzwl 0x8(%rbx), %edx
movq %rdx, 0x40(%rcx)
movzwl 0xc(%rbx), ... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::pop_rr<(SM83::Registers)10>() | void SM83::pop_rr() {
LTRACE("POP {}", Get16bitRegisterName<Register>());
StackPop(Get16bitRegisterPointer<Register>());
if constexpr (Register == Registers::AF) {
// Lowest 4 bits are always 0
f &= ~0x0F;
}
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x4(%rdi), %r14
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::call_a16<(SM83::Conditions)2>() | void SM83::call_a16() {
const u16 address = GetWordFromPC();
if constexpr (cond == Conditions::None) {
LTRACE("CALL 0x{:04X}", address);
} else {
LTRACE("CALL {}, 0x{:04X}", GetConditionString<cond>(), address);
}
if (MeetsCondition<cond>()) {
StackPush(pc);
pc = ad... | pushq %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0xb338
movl %eax, %ebp
movzwl (%rbx), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rbx), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rbx), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rbx), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rbx), %eax
movq %rax, 0x40(%rcx)
mo... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::pop_rr<(SM83::Registers)11>() | void SM83::pop_rr() {
LTRACE("POP {}", Get16bitRegisterName<Register>());
StackPop(Get16bitRegisterPointer<Register>());
if constexpr (Register == Registers::AF) {
// Lowest 4 bits are always 0
f &= ~0x0F;
}
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x6(%rdi), %r14
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::push_rr<(SM83::Registers)11>() | void SM83::push_rr() {
LTRACE("PUSH {}", Get16bitRegisterName<Register>());
StackPush(Get16bitRegister<Register>());
timer.AdvanceCycles(4);
} | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::pop_rr<(SM83::Registers)8>() | void SM83::pop_rr() {
LTRACE("POP {}", Get16bitRegisterName<Register>());
StackPop(Get16bitRegisterPointer<Register>());
if constexpr (Register == Registers::AF) {
// Lowest 4 bits are always 0
f &= ~0x0F;
}
} | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
void SM83::push_rr<(SM83::Registers)8>() | void SM83::push_rr() {
LTRACE("PUSH {}", Get16bitRegisterName<Register>());
StackPush(Get16bitRegister<Register>());
timer.AdvanceCycles(4);
} | pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movzwl (%rdi), %eax
movq %rsp, %rcx
movq %rax, (%rcx)
movzwl 0x2(%rdi), %eax
movq %rax, 0x10(%rcx)
movzwl 0x4(%rdi), %eax
movq %rax, 0x20(%rcx)
movzwl 0x6(%rdi), %eax
movq %rax, 0x30(%rcx)
movzwl 0x8(%rdi), %eax
movq %rax, 0x40(%rcx)
movzwl 0xc(%rdi), %eax
movq %rax, 0x50(%rc... | /tgsm[P]heliage/src/sm83.cpp |
cloexec_pipe | int cloexec_pipe(int fds[2])
{
#ifdef __linux__
return pipe2(fds, O_CLOEXEC);
#else
int ret = -1;
pthread_mutex_lock(&cloexec_mutex);
if (pipe(fds) != 0)
goto Exit;
if (set_cloexec(fds[0]) != 0 || set_cloexec(fds[1]) != 0)
goto Exit;
ret = 0;
Exit:
pthread_mutex_unlock(&clo... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x80000, %esi # imm = 0x80000
callq 0x40880
addq $0x10, %rsp
popq %rbp
retq
| /urbit[P]h2o/deps/cloexec/cloexec.c |
gkc_summary_free | void gkc_summary_free(struct gkc_summary *s)
{
struct freelist *fl;
struct list *cur;
cur = s->head.next;
while (cur != &s->head) {
struct list *next;
next = cur->next;
gkc_free(s, list_to_tuple(cur));
cur = next;
}
fl = s->fl;
while (fl) {
void *p;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x40fda
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax... | /urbit[P]h2o/deps/libgkc/gkc.c |
gkc_query | uint64_t gkc_query(struct gkc_summary *s, double q)
{
struct list *cur, *next;
int rank;
double gi;
double ne;
rank = 0.5 + q * s->nr_elems;
ne = s->nr_elems * s->epsilon;
gi = 0;
if (list_empty(&s->head)) {
return 0;
}
cur = s->head.next;
while (1) {
struc... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq (%rax), %xmm3
movaps 0xf2f9b(%rip), %xmm2 # 0x134030
punpckldq %xmm2, %xmm3 # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movapd 0xf2f9f(%rip), %xmm1 # 0x134040
subpd %xmm... | /urbit[P]h2o/deps/libgkc/gkc.c |
gkc_alloc | static struct gkc_tuple *gkc_alloc(struct gkc_summary *s)
{
s->alloced++;
if (s->alloced > s->max_alloced) {
s->max_alloced = s->alloced;
}
if (s->fl) {
void *ret;
ret = s->fl;
s->fl = s->fl->next;
return ret;
}
return malloc(sizeof(struct gkc_tuple));
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x4151e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
... | /urbit[P]h2o/deps/libgkc/gkc.c |
gkc_print_summary | void gkc_print_summary(struct gkc_summary *s)
{
struct gkc_tuple *tcur;
struct list *cur;
fprintf(stderr, "nr_elems: %zu, epsilon: %.02f, alloced: %" PRIu64 ", overfilled: %.02f, max_alloced: %" PRIu64 "\n",
s->nr_elems, s->epsilon, s->alloced, 2 * s->epsilon * s->nr_elems, s->max_alloced);
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1aa825(%rip), %rax # 0x1ebfb8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movsd 0x8(%rax), %xmm0
movq 0x10(%rax), %rcx
movaps %xmm0, %xmm1
addsd %xmm1, %xmm1
movq %rdx, %xmm2
movaps 0xf2877(%rip), %xmm3 # 0x134030
punpckldq %xm... | /urbit[P]h2o/deps/libgkc/gkc.c |
gkc_combine | struct gkc_summary *gkc_combine(struct gkc_summary *s1, struct gkc_summary *s2)
{
struct gkc_summary *snew;
struct list *cur1, *cur2;
struct gkc_tuple *tcur1, *tcur2, *tnew;
if (s1->epsilon != s2->epsilon) {
return NULL;
}
snew = gkc_summary_alloc(s1->epsilon);
cur1 = s1->head.next... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x418d8
jp 0x418d8
jmp 0x418e5
movq $0x0, -0x8(%rbp)
jmp 0x41c6c
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x40d20
movq %r... | /urbit[P]h2o/deps/libgkc/gkc.c |
band | static uint64_t band(struct gkc_summary *s, uint64_t delta)
{
uint64_t diff;
diff = 1 + (s->epsilon * s->nr_elems * 2) - delta;
if (diff == 1) {
return 0;
} else {
return ullog2(diff)/ullog2(2);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq (%rax), %xmm1
movaps 0xf238c(%rip), %xmm3 # 0x134030
punpckldq %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
movapd 0xf2390(%rip), %xmm2 # 0x134040
subpd %xmm2, %... | /urbit[P]h2o/deps/libgkc/gkc.c |
ullog2 | static uint64_t ullog2(uint64_t x)
{
static const uint64_t debruijn_magic = 0x022fdd63cc95386dULL;
static const uint64_t magic_table[] = {
0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28,
62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11,
63, 52, 6, 26, 37, 40, 33, 47... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x4, %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x8, %... | /urbit[P]h2o/deps/libgkc/gkc.c |
yrmcds_close | yrmcds_error yrmcds_close(yrmcds* c) {
if( c == NULL )
return YRMCDS_BAD_ARGUMENT;
if( c->sock == -1 )
return YRMCDS_OK;
close(c->sock);
c->sock = -1;
#ifndef LIBYRMCDS_NO_INTERNAL_LOCK
pthread_mutex_destroy(&(c->lock));
#endif
free(c->recvbuf);
c->recvbuf = NULL;
free(c... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41e4c
movl $0x2, -0x4(%rbp)
jmp 0x41eb9
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x41e5e
movl $0x0, -0x4(%rbp)
jmp 0x41eb9
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x3f450
movq -0x10(%rbp), %rax
movl $0xffffffff, ... | /urbit[P]h2o/deps/libyrmcds/close.c |
yrmcds_connect | yrmcds_error yrmcds_connect(yrmcds* c, const char* node, uint16_t port) {
if( c == NULL )
return YRMCDS_BAD_ARGUMENT;
#ifndef LIBYRMCDS_NO_INTERNAL_LOCK
int e = pthread_mutex_init(&(c->lock), NULL);
if( e != 0 ) {
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
#endif // ! LIBYRMCDS_NO_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41efa
movl $0x2, -0x4(%rbp)
jmp 0x4200b
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3f710
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(... | /urbit[P]h2o/deps/libyrmcds/connect.c |
connect_to_server | static yrmcds_error connect_to_server(const char* node, uint16_t port, int* server_fd) {
if( node == NULL )
return YRMCDS_BAD_ARGUMENT;
long fl;
char sport[8];
snprintf(sport, sizeof(sport), "%u", (unsigned int)port);
struct addrinfo hint, *res;
memset(&hint, 0, sizeof(hint));
hint... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4204d
movl $0x2, -0x4(%rbp)
jmp 0x423cd
leaq -0x30(%rbp), %rdi
movzwl -0x12(%rbp), %ecx
movl $0x8, %esi
leaq 0xf777e(%rip), %rdx # 0x1397df
movb $0x0, %al
callq ... | /urbit[P]h2o/deps/libyrmcds/connect.c |
yrmcds_cnt_connect | yrmcds_error yrmcds_cnt_connect(yrmcds_cnt* c, const char* node, uint16_t port) {
if( c == NULL )
return YRMCDS_BAD_ARGUMENT;
#ifndef LIBYRMCDS_NO_INTERNAL_LOCK
int e = pthread_mutex_init(&(c->lock), NULL);
if( e != 0 ) {
errno = e;
return YRMCDS_SYSTEM_ERROR;
}
#endif // ! LIBYR... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4240a
movl $0x2, -0x4(%rbp)
jmp 0x4250a
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3f710
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x4243c... | /urbit[P]h2o/deps/libyrmcds/connect.c |
yrmcds_recv | yrmcds_error yrmcds_recv(yrmcds* c, yrmcds_response* r) {
if( c == NULL || r == NULL )
return YRMCDS_BAD_ARGUMENT;
if( c->invalid )
return YRMCDS_PROTOCOL_ERROR;
if( c->last_size > 0 ) {
size_t remain = c->used - c->last_size;
if( remain > 0 )
memmove(c->recvbuf,... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4253e
cmpq $0x0, -0x18(%rbp)
jne 0x4254a
movl $0x2, -0x4(%rbp)
jmp 0x42902
movq -0x10(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0x42560
movl $0x8, -0x4(%rbp)
jmp 0x42902
movq -0x10(%rbp), %rax
cmpq $0x0, 0x5... | /urbit[P]h2o/deps/libyrmcds/recv.c |
text_recv | static yrmcds_error text_recv(yrmcds* c, yrmcds_response* r) {
char* pos;
while( c->used == 0 ||
(pos = (char*)memchr(c->recvbuf, '\n', c->used)) == NULL ) {
yrmcds_error e = recv_data(c);
if( e != 0 ) return e;
}
// make sure the buffer contains CRLF.
if( (pos - c->recvbu... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x50(%rcx)
movb %al, -0x89(%rbp)
je 0x42961
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdx
movl $0xa, %esi
callq 0x3f800
movq %rax, -0x20(... | /urbit[P]h2o/deps/libyrmcds/recv.c |
yrmcds_strerror | const char* yrmcds_strerror(yrmcds_error e) {
switch( e ) {
case YRMCDS_OK:
return "OK";
case YRMCDS_SYSTEM_ERROR:
return "Check errno for details";
case YRMCDS_BAD_ARGUMENT:
return "Bad argument";
case YRMCDS_NOT_RESOLVED:
return "Host not found";
case YRMCDS_TIM... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0x46211
movq -0x18(%rbp), %rax
leaq 0xee33d(%rip), %rcx # 0x1344a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xee26d(%rip), %rax # 0x1343e0
movq %rax, -0x8(%rbp)
jmp 0x4621c
leaq 0xe... | /urbit[P]h2o/deps/libyrmcds/strerror.c |
erase_ref | static void erase_ref(h2o_cache_t *cache, khiter_t iter, int reuse)
{
h2o_cache_ref_t *ref = kh_key(cache->table, iter);
if (!reuse)
kh_del(cache, cache->table, iter);
h2o_linklist_unlink(&ref->_lru_link);
h2o_linklist_unlink(&ref->_age_link);
cache->size -= ref->value.len;
h2o_cache_r... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x47f1f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %... | /urbit[P]h2o/lib/common/cache.c |
h2o_cache_fetch | h2o_cache_ref_t *h2o_cache_fetch(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash)
{
h2o_cache_ref_t search_key, *ref;
khiter_t iter;
int64_t timeleft;
if (keyhash == 0)
keyhash = h2o_cache_calchash(key.base, key.len);
search_key.key = key;
search_key.keyh... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x48145
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x47b50
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rb... | /urbit[P]h2o/lib/common/cache.c |
purge | static void purge(h2o_cache_t *cache, uint64_t now)
{
/* by cache size */
while (cache->capacity < cache->size) {
h2o_cache_ref_t *last;
assert(!h2o_linklist_is_empty(&cache->lru));
last = H2O_STRUCT_FROM_MEMBER(h2o_cache_ref_t, _lru_link, cache->lru.next);
erase_ref(cache, kh_ge... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4831d
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x47ec0
cmpl $0x0, %eax
jne 0x482c6
jmp 0x482e5
leaq 0xec6e6(%rip), %rdi # 0x1349b... | /urbit[P]h2o/lib/common/cache.c |
h2o_cache_release | void h2o_cache_release(h2o_cache_t *cache, h2o_cache_ref_t *ref)
{
if (__sync_fetch_and_sub(&ref->_refcnt, 1) == 1) {
assert(!h2o_linklist_is_linked(&ref->_lru_link));
assert(!h2o_linklist_is_linked(&ref->_age_link));
if (cache->destroy_cb != NULL)
cache->destroy_cb(ref->value);
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x58, %rax
lock
decq (%rax)
sete %al
testb $0x1, %al
je 0x48563
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x480c0
cmpl $0x0, %eax
jne 0x484db
jmp 0x484fa
leaq 0xec3e0(%rip), %rdi # 0x1348c2
leaq... | /urbit[P]h2o/lib/common/cache.c |
h2o_cache_set | int h2o_cache_set(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash, h2o_iovec_t value)
{
h2o_cache_ref_t *newref;
khiter_t iter;
int existed;
if (keyhash == 0)
keyhash = h2o_cache_calchash(key.base, key.len);
/* create newref */
newref = h2o_mem_alloc(siz... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x485b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x47b50
movl %eax, -0x24(%rbp)
... | /urbit[P]h2o/lib/common/cache.c |
h2o_cache_delete | void h2o_cache_delete(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash)
{
h2o_cache_ref_t search_key;
khiter_t iter;
if (keyhash == 0)
keyhash = h2o_cache_calchash(key.base, key.len);
search_key.key = key;
search_key.keyhash = keyhash;
lock_cache(cache);
... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x48ad5
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x47b50
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)... | /urbit[P]h2o/lib/common/cache.c |
h2o_filecache_clear | void h2o_filecache_clear(h2o_filecache_t *cache)
{
khiter_t iter;
for (iter = kh_begin(cache->hash); iter != kh_end(cache->hash); ++iter) {
if (!kh_exist(cache->hash, iter))
continue;
release_from_cache(cache, iter);
}
assert(kh_size(cache->hash) == 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x493d2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
... | /urbit[P]h2o/lib/common/filecache.c |
release_from_cache | static inline void release_from_cache(h2o_filecache_t *cache, khiter_t iter)
{
const char *path = kh_key(cache->hash, iter);
h2o_filecache_ref_t *ref = H2O_STRUCT_FROM_MEMBER(h2o_filecache_ref_t, _path, path);
/* detach from list */
kh_del(opencache_set, cache->hash, iter);
h2o_linklist_unlink(&ref... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x130, %rax # imm = 0xFED0
movq %rax, -0x20(%rbp)
movq -0x8(... | /urbit[P]h2o/lib/common/filecache.c |
h2o_filecache_open_file | h2o_filecache_ref_t *h2o_filecache_open_file(h2o_filecache_t *cache, const char *path, int oflag)
{
khiter_t iter = kh_get(opencache_set, cache->hash, path);
h2o_filecache_ref_t *ref;
int dummy;
/* lookup cache, and return the one if found */
if (iter != kh_end(cache->hash)) {
ref = H2O_STR... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x49730
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x49545
movq -0x8(%rbp),... | /urbit[P]h2o/lib/common/filecache.c |
h2o_filecache_close_file | void h2o_filecache_close_file(h2o_filecache_ref_t *ref)
{
if (--ref->_refcnt != 0)
return;
assert(!h2o_linklist_is_linked(&ref->_lru));
if (ref->fd != -1) {
close(ref->fd);
ref->fd = -1;
}
free(ref);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
je 0x49c84
jmp 0x49cde
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x49cf0
cmpl $0x0, %eax
jne 0x49c98
jmp 0x49cb7
leaq 0xeaf54(%rip), %rdi # 0x134bf3
l... | /urbit[P]h2o/lib/common/filecache.c |
h2o_filecache_get_last_modified | struct tm *h2o_filecache_get_last_modified(h2o_filecache_ref_t *ref, char *outbuf)
{
assert(ref->fd != -1);
if (ref->_last_modified.str[0] == '\0') {
gmtime_r(&ref->st.st_mtime, &ref->_last_modified.gm);
h2o_time2str_rfc1123(ref->_last_modified.str, &ref->_last_modified.gm);
}
if (outbuf... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x49d2b
jmp 0x49d4a
leaq 0xeaf1a(%rip), %rdi # 0x134c4c
leaq 0xead91(%rip), %rsi # 0x134aca
movl $0x99, %edx
leaq 0xeaf15(%rip), %rcx # 0x134c5a
callq 0x3f2e0
movq -0x8(%rbp),... | /urbit[P]h2o/lib/common/filecache.c |
h2o_hostinfo_getaddr | h2o_hostinfo_getaddr_req_t *h2o_hostinfo_getaddr(h2o_multithread_receiver_t *receiver, h2o_iovec_t name, h2o_iovec_t serv,
int family, int socktype, int protocol, int flags, h2o_hostinfo_getaddr_cb cb,
void *cbdata)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x... | /urbit[P]h2o/lib/common/hostinfo.c |
h2o_hostinfo_getaddr_receiver | void h2o_hostinfo_getaddr_receiver(h2o_multithread_receiver_t *receiver, h2o_linklist_t *messages)
{
while (!h2o_linklist_is_empty(messages)) {
h2o_hostinfo_getaddr_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_hostinfo_getaddr_req_t, _out.message.link, messages->next);
h2o_linklist_unlink(&req->_out.mess... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a8f0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4a85a
jmp 0x4a8dd
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $-0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0... | /urbit[P]h2o/lib/common/hostinfo.c |
fetch_aton_digit | static const char *fetch_aton_digit(const char *p, const char *end, unsigned char *value)
{
size_t ndigits = 0;
int v = 0;
while (p != end && ('0' <= *p && *p <= '9')) {
v = v * 10 + *p++ - '0';
++ndigits;
}
if (!(1 <= ndigits && ndigits <= 3))
return NULL;
if (v > 255)
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x2d(%rbp)
je 0x4aa39
movq -0x10(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %e... | /urbit[P]h2o/lib/common/hostinfo.c |
lookup_thread_main | static void *lookup_thread_main(void *_unused)
{
pthread_mutex_lock(&queue.mutex);
while (1) {
--queue.num_threads_idle;
while (!h2o_linklist_is_empty(&queue.pending)) {
h2o_hostinfo_getaddr_req_t *req = H2O_STRUCT_FROM_MEMBER(h2o_hostinfo_getaddr_req_t, _pending, queue.pending.next... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1a229d(%rip), %rdi # 0x1ecd70
callq 0x3f4f0
movq 0x1a2301(%rip), %rax # 0x1ecde0
addq $-0x1, %rax
movq %rax, 0x1a22f6(%rip) # 0x1ecde0
leaq 0x1a227f(%rip), %rdi # 0x1ecd70
addq $0x58, %rdi
callq 0x4a8f0
cmpl $0x0, %eax
setne %al
xorb $... | /urbit[P]h2o/lib/common/hostinfo.c |
create_client | static struct st_h2o_http1client_private_t *create_client(h2o_http1client_t **_client, void *data, h2o_http1client_ctx_t *ctx,
h2o_iovec_t ssl_server_name, h2o_http1client_connect_cb cb)
{
struct st_h2o_http1client_private_t *client = h2o_mem_alloc(sizeof(*c... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x90, %edi
callq 0x4b450
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
mo... | /urbit[P]h2o/lib/common/http1client.c |
on_handshake_complete | static void on_handshake_complete(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_private_t *client = sock->data;
h2o_timeout_unlink(&client->_timeout);
if (err == NULL) {
/* success */
} else if (err == h2o_socket_error_ssl_cert_name_mismatch &&
(SSL_CTX_get_ve... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x58bf0
cmpq $0x0, -0x10(%rbp)
jne 0x4b561
jmp 0x4b59c
movq -0x10(%rbp), %rax
leaq 0x1a28bc(%rip), %rcx # 0x1ede28
cmpq... | /urbit[P]h2o/lib/common/http1client.c |
on_send_request | static void on_send_request(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_private_t *client = sock->data;
h2o_timeout_unlink(&client->_timeout);
if (err != NULL) {
on_error_before_head(client, "I/O error (send request)");
return;
}
h2o_socket_read_start(client->... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x58bf0
cmpq $0x0, -0x10(%rbp)
je 0x4b691
movq -0x18(%rbp), %rdi
leaq 0xe96da(%rip), %rsi # 0x134d64
callq 0x4b710
jmp... | /urbit[P]h2o/lib/common/http1client.c |
on_head | static void on_head(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_private_t *client = sock->data;
int minor_version, http_status, rlen, is_eos;
const char *msg;
#define MAX_HEADERS 100
h2o_header_t *headers;
h2o_iovec_t *header_names;
size_t msg_len, num_headers, i;
h2o_so... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xde8, %rsp # imm = 0xDE8
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x58bf0
cmpq $0x0, -0x18(%rbp)
je 0x4b818
movq -0x20(%rbp), %rdi
leaq 0xe9632(%rip)... | /urbit[P]h2o/lib/common/http1client.c |
on_body_until_close | static void on_body_until_close(h2o_socket_t *sock, const char *err)
{
struct st_h2o_http1client_private_t *client = sock->data;
h2o_timeout_unlink(&client->_timeout);
if (err != NULL) {
client->_cb.on_body(&client->super, h2o_http1client_error_is_eos);
close_client(client);
return... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x58bf0
cmpq $0x0, -0x10(%rbp)
je 0x4c0ef
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rdi
leaq 0xf893f... | /urbit[P]h2o/lib/common/http1client.c |
h2o_memis | inline int h2o_memis(const void *_target, size_t target_len, const void *_test, size_t test_len)
{
const char *target = (const char *)_target, *test = (const char *)_test;
if (target_len != test_len)
return 0;
if (target_len == 0)
return 1;
if (target[0] != test[0])
return 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x5f73b
movl $0x0, -0x4(%rbp)
jmp 0x5f791
c... | /urbit[P]h2o/include/h2o/memory.h |
append_unsafe_string_json | static char *append_unsafe_string_json(char *pos, const char *src, size_t len)
{
const char *src_end = src + len;
for (; src != src_end; ++src) {
if (' ' <= *src && *src < 0x7e) {
if (*src == '"' || *src == '\\')
*pos++ = '\\';
*pos++ = *src;
} else {
... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x6646a
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl $0x20, %eax
cmpl %ecx, %eax
jg 0x663bc
movq -0x10(%... | /urbit[P]h2o/lib/core/logconf.c |
h2o_url_hosts_are_equal | static inline int h2o_url_hosts_are_equal(const h2o_url_t *url_a, const h2o_url_t *url_b)
{
if (url_a->host.len != url_b->host.len)
return 0;
if (h2o_url_host_is_unix_path(url_a->host))
return h2o_memis(url_a->host.base, url_a->host.len, url_b->host.base, url_b->host.len);
else
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x6996b
movl $0x0, -0x4(%rbp)
jmp 0x699d3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x69a20
cmpl $0x0, %ea... | /urbit[P]h2o/include/h2o/url.h |
append_chunk | __attribute__((format(printf, 3, 4))) static void append_chunk(h2o_mem_pool_t *pool, h2o_iovec_vector_t *chunks, const char *fmt,
...)
{
va_list args;
va_start(args, fmt);
int size = vsnprintf(NULL, 0, fmt, args);
va_end(args);
assert(... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
testb %al, %al
je 0x96c9e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(... | /urbit[P]h2o/lib/http2/http2_debug_state.c |
append_header_table_chunks | static void append_header_table_chunks(h2o_mem_pool_t *pool, h2o_iovec_vector_t *chunks, h2o_hpack_header_table_t *header_table)
{
int i;
for (i = 0; i < header_table->num_entries; i++) {
h2o_hpack_header_table_entry_t *entry = h2o_hpack_header_table_get(header_table, i);
append_chunk(pool, chun... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x96f30
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x96fe0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %r... | /urbit[P]h2o/lib/http2/http2_debug_state.c |
yaml_string_extend | YAML_DECLARE(int)
yaml_string_extend(yaml_char_t **start,
yaml_char_t **pointer, yaml_char_t **end)
{
yaml_char_t *new_start = yaml_realloc(*start, (*end - *start)*2);
if (!new_start) return 0;
memset(new_start + (*end - *start), 0, *end - *start);
*pointer = new_start + (*pointer - *start);
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq %rax, %rsi
shlq %rsi
callq 0x970e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp... | /urbit[P]h2o/deps/yaml/src/api.c |
yaml_string_join | YAML_DECLARE(int)
yaml_string_join(
yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end)
{
if (*b_start == *b_pointer)
return 1;
while (*a_end - *a_pointer <= *b_pointer - *b_start) {
if (!yaml_... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x972fc
movl $0x1, -0x4(%rbp)
jmp 0x9738c
jmp 0x972fe
... | /urbit[P]h2o/deps/yaml/src/api.c |
yaml_queue_extend | YAML_DECLARE(int)
yaml_queue_extend(void **start, void **head, void **tail, void **end)
{
/* Check if we need to resize the queue. */
if (*start == *head && *tail == *end) {
void *new_start = yaml_realloc(*start,
((char *)*end - (char *)*start)*2);
if (!new_start) return 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x97532
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x97... | /urbit[P]h2o/deps/yaml/src/api.c |
yaml_parser_scan_directive_name | static int
yaml_parser_scan_directive_name(yaml_parser_t *parser,
yaml_mark_t start_mark, yaml_char_t **name)
{
yaml_string_t string = NULL_STRING;
if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
/* Consume the directive name. */
if (!CACHE(parser, 1)) goto error;
whil... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xb2e28
movq -0x30(%rbp), %rax
movq %rax, ... | /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_save_simple_key | static int
yaml_parser_save_simple_key(yaml_parser_t *parser)
{
/*
* A simple key is required at the current position if the scanner is in
* the block context and the current column coincides with the indentation
* level.
*/
int required = (!parser->flow_level
&& parser->indent ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x100(%rcx)
movb %al, -0x41(%rbp)
jne 0xb5d1a
movq -0x10(%rbp), %rax
movslq 0x150(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0xf0(%rcx), %rax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, ... | /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_roll_indent | static int
yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark)
{
yaml_token_t token;
/* In the flow context, do nothing. */
if (parser->flow_level)
return 1;
if (parser->indent < column)
{
/*
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x100(%rax)
je 0xb5fbb
movl $0x1, -0x4(%rbp)
jmp 0xb62e4
movq -0x10(%rbp), %rax
movslq 0x150(%rax), %rax
... | /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_scan_anchor | static int
yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token,
yaml_token_type_t type)
{
int length = 0;
yaml_mark_t start_mark, end_mark;
yaml_string_t string = NULL_STRING;
if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
/* Eat the indicator character. ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
movl $0x10, %edi
callq 0x970a0
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0xb635d
movq -0x68(%rbp), %rax
movq %rax,... | /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_scan_tag | static int
yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
{
yaml_char_t *handle = NULL;
yaml_char_t *suffix = NULL;
yaml_mark_t start_mark, end_mark;
start_mark = parser->mark;
/* Check if the tag is in the canonical form. */
if (!CACHE(parser, 2)) goto error;
if (CHECK... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xe0(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0xe8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0xf0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmp... | /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_scan_block_scalar | static int
yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token,
int literal)
{
yaml_mark_t start_mark;
yaml_mark_t end_mark;
yaml_string_t string = NULL_STRING;
yaml_string_t leading_break = NULL_STRING;
yaml_string_t trailing_breaks = NULL_STRING;
int chomping = 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
mo... | /urbit[P]h2o/deps/yaml/src/scanner.c |
yaml_parser_scan_plain_scalar | static int
yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token)
{
yaml_mark_t start_mark;
yaml_mark_t end_mark;
yaml_string_t string = NULL_STRING;
yaml_string_t leading_break = NULL_STRING;
yaml_string_t trailing_breaks = NULL_STRING;
yaml_string_t whitespaces = NULL_STRING... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3f5b0
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x... | /urbit[P]h2o/deps/yaml/src/scanner.c |
brotli::ZopfliIterate(unsigned long, unsigned long, unsigned char const*, unsigned long, unsigned long, brotli::ZopfliCostModel const&, std::vector<unsigned int, std::allocator<unsigned int>> const&, std::vector<brotli::BackwardMatch, std::allocator<brotli::BackwardMatch>> const&, int*, unsigned long*, brotli::Command*... | void ZopfliIterate(size_t num_bytes,
size_t position,
const uint8_t* ringbuffer,
size_t ringbuffer_mask,
const size_t max_backward_limit,
const ZopfliCostModel& model,
const std::vector<uint32_t>& num_match... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x398, %rsp # imm = 0x398
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
brotli::CombineLengthCodes(unsigned short, unsigned short, bool) | static inline uint16_t CombineLengthCodes(
uint16_t inscode, uint16_t copycode, bool use_last_distance) {
uint16_t bits64 =
static_cast<uint16_t>((copycode & 0x7u) | ((inscode & 0x7u) << 3));
if (use_last_distance && inscode < 8 && copycode < 16) {
return (copycode < 8) ? bits64 : (bits64 | 64);
} e... | pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movw %si, %cx
movw %di, %dx
movw %dx, -0x4(%rbp)
movw %cx, -0x6(%rbp)
andb $0x1, %al
movb %al, -0x7(%rbp)
movzwl -0x6(%rbp), %eax
andl $0x7, %eax
movzwl -0x4(%rbp), %ecx
andl $0x7, %ecx
shll $0x3, %ecx
orl %ecx, %eax
movw %ax, -0xa(%rbp)
testb $0x1, -0x7(%rbp)
je 0xc162d
movzwl ... | /urbit[P]h2o/deps/brotli/enc/././command.h |
brotli::Log2FloorNonZero(unsigned long) | static inline uint32_t Log2FloorNonZero(size_t n) {
#ifdef __GNUC__
return 31u ^ static_cast<uint32_t>(__builtin_clz(static_cast<uint32_t>(n)));
#else
uint32_t result = 0;
while (n >>= 1) result++;
return result;
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
bsrl %eax, %eax
xorl $0x1f, %eax
xorl $0x1f, %eax
popq %rbp
retq
nopw (%rax,%rax)
| /urbit[P]h2o/deps/brotli/enc/./././fast_log.h |
brotli::GetLengthCode(unsigned long, unsigned long, bool, unsigned short*, unsigned long*) | static inline void GetLengthCode(size_t insertlen, size_t copylen,
bool use_last_distance,
uint16_t* code, uint64_t* extra) {
uint16_t inscode = GetInsertLengthCode(insertlen);
uint16_t copycode = GetCopyLengthCode(copylen);
uint64_t insnumextra = ... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc1460
movw %ax, -0x2a(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc1520
movw %ax, -0x2c(%rbp)
movzwl -0x2a(%rbp)... | /urbit[P]h2o/deps/brotli/enc/././command.h |
brotli::StartPosQueue::Push(unsigned long, double) | void Push(size_t pos, double costdiff) {
if (costdiff == kInfinity) {
// We can't start a command from an unreachable start position.
// E.g. position 1 in a stream is always unreachable, because all commands
// have a copy of at least length 2.
return;
}
size_t offset = -idx_ & mask... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x830de(%rip), %xmm1 # 0x144bb8
ucomisd %xmm1, %xmm0
jne 0xc1ae7
jp 0xc1ae7
jmp 0xc1c03
movq -0x48(%rbp), %rdi
xorl %eax, %eax
... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
brotli::ZopfliCostModel::GetCommandCost(unsigned long, unsigned long, unsigned long) const | double GetCommandCost(
size_t dist_code, size_t length_code, size_t insert_length) const {
uint16_t inscode = GetInsertLengthCode(insert_length);
uint16_t copycode = GetCopyLengthCode(length_code);
uint16_t cmdcode = CombineLengthCodes(inscode, copycode, dist_code == 0);
uint16_t dist_symbol;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc1460
movw %ax, -0x22(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc1520
movw %ax, -0x24(%rbp)
movzwl -0x22(%rbp), %e... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
brotli::Command::Command(unsigned long, unsigned long, unsigned long, unsigned long) | Command(size_t insertlen, size_t copylen, size_t copylen_code,
size_t distance_code)
: insert_len_(static_cast<uint32_t>(insertlen))
, copy_len_(static_cast<uint32_t>(copylen)) {
// The distance prefix and extra bits are stored in this Command as if
// npostfix and ndirect were 0, they are... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %r8
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl %eax, (%r8)
movq -0x18(%rbp), %rax
movl %eax, 0x4(%r8)
movq -0x28(%rbp), %rdi
movq %r8, %rcx... | /urbit[P]h2o/deps/brotli/enc/././command.h |
brotli::HashToBinaryTree::FindAllMatches(unsigned char const*, unsigned long, unsigned long, unsigned long, unsigned long, brotli::BackwardMatch*) | size_t FindAllMatches(const uint8_t* data,
const size_t ring_buffer_mask,
const size_t cur_ix,
const size_t max_length,
const size_t max_backward,
BackwardMatch* matches) {
BackwardMatch* const or... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
mov... | /urbit[P]h2o/deps/brotli/enc/././hash.h |
brotli::ZopfliCostModel::SetFromLiteralCosts(unsigned long, unsigned long, unsigned char const*, unsigned long) | void SetFromLiteralCosts(size_t num_bytes,
size_t position,
const uint8_t* ringbuffer,
size_t ringbuffer_mask) {
std::vector<float> literal_cost(num_bytes + 1);
EstimateBitCostsForLiterals(position, num_bytes, ringbuffer_mask,
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
incq %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xc8610
mo... | /urbit[P]h2o/deps/brotli/enc/backward_references.cc |
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.