name string | code string | asm string | file string |
|---|---|---|---|
p_cond_variable_new | P_LIB_API PCondVariable *
p_cond_variable_new (void)
{
PCondVariable *ret;
if (P_UNLIKELY ((ret = p_malloc0 (sizeof (PCondVariable))) == NULL)) {
P_ERROR ("PCondVariable::p_cond_variable_new: failed to allocate memory");
return NULL;
}
if (P_UNLIKELY (pthread_cond_init (&ret->hdl, NULL) != 0)) {
P_ERROR ("P... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x6700
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2472d
leaq 0x3917(%rip), %rdi # 0x2802c
leaq 0x5155(%rip), %rsi # 0x29871
movb $0x0, %al
callq 0x6... | /saprykin[P]plibsys/src/pcondvariable-posix.c |
p_mutex_new | P_LIB_API PMutex *
p_mutex_new (void)
{
PMutex *ret;
if (P_UNLIKELY ((ret = p_malloc0 (sizeof (PMutex))) == NULL)) {
P_ERROR ("PMutex::p_mutex_new: failed to allocate memory");
return NULL;
}
if (P_UNLIKELY (pthread_mutex_init (&ret->hdl, NULL) != 0)) {
P_ERROR ("PMutex::p_mutex_new: pthread_mutex_init() fa... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x6700
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x24a0d
leaq 0x3637(%rip), %rdi # 0x2802c
leaq 0x4ffc(%rip), %rsi # 0x299f8
movb $0x0, %al
callq 0x6... | /saprykin[P]plibsys/src/pmutex-posix.c |
p_mutex_lock | P_LIB_API pboolean
p_mutex_lock (PMutex *mutex)
{
if (P_UNLIKELY (mutex == NULL))
return FALSE;
if (P_LIKELY (pthread_mutex_lock (&mutex->hdl) == 0))
return TRUE;
else {
P_ERROR ("PMutex::p_mutex_lock: pthread_mutex_lock() failed");
return FALSE;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x24a9e
movl $0x0, -0x4(%rbp)
jmp 0x24ae3
movq -0x10(%rbp), %rdi
callq 0x6aa0
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %a... | /saprykin[P]plibsys/src/pmutex-posix.c |
p_semaphore_new | P_LIB_API PSemaphore *
p_semaphore_new (const pchar *name,
pint init_val,
PSemaphoreAccessMode mode,
PError **error)
{
PSemaphore *ret;
pchar *new_name;
if (P_UNLIKELY (name == NULL || init_val < 0)) {
p_error_set_error_p (error,
(pint) P_ERROR_IPC_INVALID_ARGUMENT,
0,
"I... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x31(%rbp)
je 0x24c6c
cmpl $0x0, -0x14(%rbp)
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb ... | /saprykin[P]plibsys/src/psemaphore-posix.c |
pp_semaphore_create_handle | static pboolean
pp_semaphore_create_handle (PSemaphore *sem,
PError **error)
{
pint init_val;
if (P_UNLIKELY (sem == NULL || sem->platform_key == NULL)) {
p_error_set_error_p (error,
(pint) P_ERROR_IPC_INVALID_ARGUMENT,
0,
"Invalid input argument");
return FALSE;
}
init_val =... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x1d(%rbp)
je 0x24e1b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ea... | /saprykin[P]plibsys/src/psemaphore-posix.c |
p_shm_new | P_LIB_API PShm *
p_shm_new (const pchar *name,
psize size,
PShmAccessPerms perms,
PError **error)
{
PShm *ret;
pchar *new_name;
if (P_UNLIKELY (name == NULL)) {
p_error_set_error_p (error,
(pint) P_ERROR_IPC_INVALID_ARGUMENT,
0,
"Invalid input argument");
return NULL;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x25304
movq -0x28(%rbp), %rdi
movl $0x25f, %esi # im... | /saprykin[P]plibsys/src/pshm-posix.c |
pp_shm_create_handle | static pboolean
pp_shm_create_handle (PShm *shm,
PError **error)
{
pboolean is_exists;
pint fd;
pint flags;
struct stat stat_buf;
if (P_UNLIKELY (shm == NULL || shm->platform_key == NULL)) {
p_error_set_error_p (error,
(pint) P_ERROR_IPC_INVALID_ARGUMENT,
0,
"Invalid input a... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0xb9(%rbp)
je 0x25534
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
sete %al
movb %al, -0xb9(%rbp)
movb -0xb9(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb... | /saprykin[P]plibsys/src/pshm-posix.c |
p_uthread_set_name_internal | void
p_uthread_set_name_internal (PUThread *thread)
{
pchar *thr_name = NULL;
pint res = 0;
pboolean is_alloc = FALSE;
#ifdef PUTHREAD_MAX_NAME
psize namelen = 0;
#endif
thr_name = thread->base.name;
#ifdef PUTHREAD_MAX_NAME
namelen = strlen (thr_name);
if (namelen > PUTHREAD_MAX_NAME - 1)... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6220
movq %rax, -0x20(%rbp)
cmpq $0xf, -0x20(%rbp)
jbe 0x26287
m... | /saprykin[P]plibsys/src/puthread-posix.c |
p_uthread_local_new | P_LIB_API PUThreadKey *
p_uthread_local_new (PDestroyFunc free_func)
{
PUThreadKey *ret;
if (P_UNLIKELY ((ret = p_malloc0 (sizeof (PUThreadKey))) == NULL)) {
P_ERROR ("PUThread::p_uthread_local_new: failed to allocate memory");
return NULL;
}
ret->free_func = free_func;
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x10, %edi
callq 0x6700
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x264a1
leaq 0x1ba3(%rip), %rdi # 0x2802c
leaq 0x3e2a(%rip), %rsi # 0x2a2ba
m... | /saprykin[P]plibsys/src/puthread-posix.c |
p_dir_rewind | P_LIB_API pboolean
p_dir_rewind (PDir *dir,
PError **error)
{
if (P_UNLIKELY (dir == NULL || dir->dir == NULL)) {
p_error_set_error_p (error,
(pint) P_ERROR_IO_INVALID_ARGUMENT,
0,
"Invalid input argument");
return FALSE;
}
rewinddir (dir->dir);
return TRUE;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x2715a
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
c... | /saprykin[P]plibsys/src/pdir-posix.c |
p_rwlock_new | P_LIB_API PRWLock *
p_rwlock_new (void)
{
PRWLock *ret;
if (P_UNLIKELY ((ret = p_malloc0 (sizeof (PRWLock))) == NULL)) {
P_ERROR ("PRWLock::p_rwlock_new: failed to allocate memory");
return NULL;
}
if (P_UNLIKELY (pthread_rwlock_init (&ret->hdl, NULL) != 0)) {
P_ERROR ("PRWLock::p_rwlock_new: pthread_rwlock... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x38, %edi
callq 0x6700
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2752d
leaq 0xb17(%rip), %rdi # 0x2802c
leaq 0x321b(%rip), %rsi # 0x2a737
movb $0x0, %al
callq 0x6... | /saprykin[P]plibsys/src/prwlock-posix.c |
p_rwlock_reader_lock | P_LIB_API pboolean
p_rwlock_reader_lock (PRWLock *lock)
{
if (P_UNLIKELY (lock == NULL))
return FALSE;
if (P_UNLIKELY (pthread_rwlock_rdlock (&lock->hdl) == 0))
return TRUE;
else {
P_ERROR ("PRWLock::p_rwlock_reader_lock: pthread_rwlock_rdlock() failed");
return FALSE;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x275be
movl $0x0, -0x4(%rbp)
jmp 0x27603
movq -0x10(%rbp), %rdi
callq 0x6400
cmpl $0x0, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %a... | /saprykin[P]plibsys/src/prwlock-posix.c |
enet_host_destroy | void
enet_host_destroy (ENetHost * host)
{
ENetPeer * currentPeer;
int i;
if (host == NULL)
return;
enet_socket_destroy (host -> socket);
for (i = 0; i < host -> peerCount; i++ )
{
currentPeer = host -> peer_list[i];
enet_peer_reset (currentPeer);
enet_free (current... | testq %rdi, %rdi
je 0x39fb
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x2050
cmpq $0x0, 0x30(%rbx)
je 0x39cb
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %r14
movq %r14, %rdi
callq 0x2080
movq %r14, %rdi
callq 0x2150
movq 0x28(%rbx), %rax
movq $0x0, (%rax,%r15,8)
incq %r15
c... | /ornladios[P]ADIOS2/thirdparty/enet/enet/host.c |
enet_host_connect | ENetPeer *
enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelCount, enet_uint32 data)
{
ENetPeer * currentPeer;
ENetChannel * channel;
ENetProtocol command;
int i;
if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)
channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movq %rsi, %r12
movl $0xff, %eax
cmpq %rax, %rdx
cmovbq %rdx, %rax
testq %rdx, %rdx
movl $0x1, %r13d
cmovneq %rax, %r13
movq %rdi, %r15
movq 0x30(%rdi), %rax
testq %rax, %rax
setne %cl
je 0x3a66
movq 0x28(%r15), %rdx
movq... | /ornladios[P]ADIOS2/thirdparty/enet/enet/host.c |
enet_list_insert | ENetListIterator
enet_list_insert (ENetListIterator position, void * data)
{
ENetListIterator result = (ENetListIterator) data;
result -> previous = position -> previous;
result -> next = position;
result -> previous -> next = result;
position -> previous = result;
return result;
} | movq %rsi, %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rsi)
movq %rdi, (%rsi)
movq %rsi, (%rcx)
movq %rsi, 0x8(%rdi)
retq
| /ornladios[P]ADIOS2/thirdparty/enet/enet/list.c |
enet_list_size | size_t
enet_list_size (ENetList * list)
{
size_t size = 0;
ENetListIterator position;
for (position = enet_list_begin (list);
position != enet_list_end (list);
position = enet_list_next (position))
++ size;
return size;
} | movq $-0x1, %rax
movq %rdi, %rcx
movq (%rcx), %rcx
incq %rax
cmpq %rdi, %rcx
jne 0x40d4
retq
| /ornladios[P]ADIOS2/thirdparty/enet/enet/list.c |
enet_packet_resize | int
enet_packet_resize (ENetPacket * packet, size_t dataLength)
{
enet_uint8 * newData;
if (dataLength <= packet -> dataLength || (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE))
{
packet -> dataLength = dataLength;
return 0;
}
newData = (enet_uint8 *) enet_malloc (dataLength);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jae 0x41e9
testb $0x4, 0x8(%r14)
jne 0x41e9
movq %rbx, %rdi
callq 0x20c0
testq %rax, %rax
je 0x41f5
movq %rax, %r15
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rax, %rdi
callq 0x2220
movq 0x10(%r14), %rdi
callq 0x2150
movq %r15... | /ornladios[P]ADIOS2/thirdparty/enet/enet/packet.c |
enet_peer_reset_outgoing_commands | static void
enet_peer_reset_outgoing_commands (ENetList * queue)
{
ENetOutgoingCommand * outgoingCommand;
while (! enet_list_empty (queue))
{
outgoingCommand = (ENetOutgoingCommand *) enet_list_remove (enet_list_begin (queue));
if (outgoingCommand -> packet != NULL)
{
-- out... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
cmpq %rbx, %rdi
je 0x4932
callq 0x2270
movq %rax, %r14
movq 0x60(%rax), %rdi
testq %rdi, %rdi
je 0x4925
decq (%rdi)
jne 0x4925
callq 0x2340
movq %r14, %rdi
callq 0x2150
movq (%rbx), %rdi
jmp 0x4905
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_peer_reset | void
enet_peer_reset (ENetPeer * peer)
{
enet_peer_on_disconnect (peer);
peer -> outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID;
peer -> connectID = 0;
peer -> state = ENET_PEER_STATE_DISCONNECTED;
peer -> incomingBandwidth = 0;
peer -> outgoingBandwidth = 0;
peer -> incomingBandw... | pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
addl $-0x5, %eax
cmpl $0x1, %eax
ja 0x49b5
cmpl $0x0, 0x50(%rbx)
je 0x49aa
movq 0x10(%rbx), %rax
decq 0x2b30(%rax)
movq 0x10(%rbx), %rax
decq 0x2b28(%rax)
movl $0xffffff, 0x18(%rbx) # imm = 0xFFFFFF
xorl %eax, %eax
movl %eax, 0x20(%rbx)
movl %eax, 0x38(%rbx)
xorps %xmm... | /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_peer_ping | void
enet_peer_ping (ENetPeer * peer)
{
ENetProtocol command;
if (peer -> state != ENET_PEER_STATE_CONNECTED)
return;
command.header.command = ENET_PROTOCOL_COMMAND_PING | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE;
command.header.channelID = 0xFF;
enet_peer_queue_outgoing_command (peer, & c... | cmpl $0x5, 0x38(%rdi)
jne 0x4a82
subq $0x38, %rsp
leaq 0x6(%rsp), %rsi
movw $0xff85, (%rsi) # imm = 0xFF85
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x20b0
addq $0x38, %rsp
retq
| /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_peer_disconnect_now | void
enet_peer_disconnect_now (ENetPeer * peer, enet_uint32 data)
{
ENetProtocol command;
if (peer -> state == ENET_PEER_STATE_DISCONNECTED)
return;
if (peer -> state != ENET_PEER_STATE_ZOMBIE &&
peer -> state != ENET_PEER_STATE_DISCONNECTING)
{
enet_peer_reset_queues (peer);
... | movl 0x38(%rdi), %eax
testl %eax, %eax
je 0x4b1e
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpl $0x7, %eax
je 0x4b10
cmpl $0x9, %eax
je 0x4b10
movl %esi, %ebp
movq %rbx, %rdi
callq 0x22c0
leaq 0x6(%rsp), %rsi
movw $0xff44, (%rsi) # imm = 0xFF44
bswapl %ebp
movl %ebp, 0x4(%rsi)
movq %rbx, %rdi
xorl ... | /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_peer_disconnect | void
enet_peer_disconnect (ENetPeer * peer, enet_uint32 data)
{
ENetProtocol command;
if (peer -> state == ENET_PEER_STATE_DISCONNECTING ||
peer -> state == ENET_PEER_STATE_DISCONNECTED ||
peer -> state == ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT ||
peer -> state == ENET_PEER_STATE_ZOMB... | pushq %rbp
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl 0x38(%rdi), %eax
cmpl $0x9, %eax
ja 0x4b43
movl $0x381, %ecx # imm = 0x381
btl %eax, %ecx
jae 0x4b43
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x22c0
leaq 0x6(%rsp), %rsi
movw $0xff04, (%rsi) # imm = 0xF... | /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_peer_queue_acknowledgement | ENetAcknowledgement *
enet_peer_queue_acknowledgement (ENetPeer * peer, const ENetProtocol * command, enet_uint16 sentTime)
{
ENetAcknowledgement * acknowledgement;
if (command -> header.channelID < peer -> channelCount)
{
ENetChannel * channel = & peer -> channels [command -> header.channelID];
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x1(%rsi), %eax
cmpq %rax, 0x48(%rdi)
jbe 0x4c73
movq 0x40(%rbx), %rcx
movzwl 0x2(%r14), %edx
movl %edx, %esi
shrl $0xc, %esi
leaq (%rax,%rax,4), %rax
shll $0x4, %eax
movzwl 0x26(%rcx,%rax), %eax
movl %eax, %ec... | /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_peer_dispatch_incoming_unreliable_commands | void
enet_peer_dispatch_incoming_unreliable_commands (ENetPeer * peer, ENetChannel * channel)
{
ENetListIterator droppedCommand, startCommand, currentCommand;
for (droppedCommand = startCommand = currentCommand = enet_list_begin (& channel -> incomingUnreliableCommands);
currentCommand != enet_list_en... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r8
leaq 0x40(%rsi), %rbp
movq 0x40(%rsi), %r12
cmpq %rbp, %r12
movq %rdi, (%rsp)
je 0x4e5d
leaq 0x130(%r8), %rax
movq %rax, 0x10(%rsp)
movq %r12, %r13
movq %r12, %r14
movq %rsi, 0x8(%rsp)
movb 0x14(%r14), %al
andb $0xf, %al
m... | /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_peer_remove_incoming_commands | static void
enet_peer_remove_incoming_commands (ENetList * queue, ENetListIterator startCommand, ENetListIterator endCommand)
{
ENetListIterator currentCommand;
for (currentCommand = startCommand; currentCommand != endCommand; )
{
ENetIncomingCommand * incomingCommand = (ENetIncomingCommand ... | cmpq %rsi, %rdi
je 0x4f0d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%r14), %r15
movq %r14, %rdi
callq 0x2270
movq 0x58(%r14), %rdi
testq %rdi, %rdi
je 0x4eea
decq (%rdi)
jne 0x4eea
callq 0x2340
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x4ef8
callq 0x2150
movq %r14, %rdi
callq 0x2150
movq %... | /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_peer_dispatch_incoming_reliable_commands | void
enet_peer_dispatch_incoming_reliable_commands (ENetPeer * peer, ENetChannel * channel)
{
ENetListIterator currentCommand;
for (currentCommand = enet_list_begin (& channel -> incomingReliableCommands);
currentCommand != enet_list_end (& channel -> incomingReliableCommands);
currentCommand... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsi), %rcx
movq 0x30(%rsi), %rax
cmpq %rcx, %rax
je 0x4f52
cmpl $0x0, 0x4c(%rax)
jne 0x4f52
movzwl 0x10(%rax), %edx
movzwl 0x26(%rbx), %esi
incl %esi
cmpw %si, %dx
jne 0x4f52
movw %dx, 0x26(%rbx)
movl 0x48(%rax), %esi
testl %esi, %esi
je 0x4f4d... | /ornladios[P]ADIOS2/thirdparty/enet/enet/peer.c |
enet_protocol_send_outgoing_commands | static int
enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int checkForTimeouts)
{
enet_uint8 headerData [sizeof (ENetProtocolHeader) + sizeof (enet_uint32)];
ENetProtocolHeader * header = (ENetProtocolHeader *) headerData;
ENetPeer * currentPeer;
int sentLength;
size_t sho... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, 0x28(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdi, %r15
movl $0x1, 0x58(%rdi)
leaq 0x6c(%rdi), %rax
movq %rax, 0x50(%rsp)
leaq 0x6b8(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x6c8(%rdi), %rax
movq %rax, 0x48(%rsp)
leaq 0x1af8(%rdi), %r... | /ornladios[P]ADIOS2/thirdparty/enet/enet/protocol.c |
enet_protocol_dispatch_incoming_commands | static int
enet_protocol_dispatch_incoming_commands (ENetHost * host, ENetEvent * event)
{
while (! enet_list_empty (& host -> dispatchQueue))
{
ENetPeer * peer = (ENetPeer *) enet_list_remove (enet_list_begin (& host -> dispatchQueue));
peer -> needsDispatch = 0;
switch (peer -> state)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
leaq 0x48(%rdi), %r15
movq 0x48(%rdi), %rdi
xorl %ebp, %ebp
cmpq %r15, %rdi
je 0x5c47
movq %rsi, %r14
leaq 0x10(%rsi), %rbp
callq 0x2270
movq %rax, %r12
movl $0x0, 0x140(%rax)
movl 0x38(%rax), %eax
cmpl $0x5, %eax
je 0x5bbd
lea... | /ornladios[P]ADIOS2/thirdparty/enet/enet/protocol.c |
enet_host_service | int
enet_host_service (ENetHost * host, ENetEvent * event, enet_uint32 timeout)
{
enet_uint32 waitCondition;
if (event != NULL)
{
event -> type = ENET_EVENT_TYPE_NONE;
event -> peer = NULL;
event -> packet = NULL;
switch (enet_protocol_dispatch_incoming_commands (host, even... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x5cdb
movl $0x0, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x18(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b6c
movl %eax, %r13d
cmpl $-0x1, %eax
je 0x7... | /ornladios[P]ADIOS2/thirdparty/enet/enet/protocol.c |
enet_protocol_send_reliable_outgoing_commands | static int
enet_protocol_send_reliable_outgoing_commands (ENetHost * host, ENetPeer * peer)
{
ENetProtocol * command = & host -> commands [host -> commandCount];
ENetBuffer * buffer = & host -> buffers [host -> bufferCount];
ENetOutgoingCommand * outgoingCommand;
ENetListIterator currentCommand;
ENe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r11
imulq $0x32, 0x6b0(%rdi), %rbp
addq $0x6c, %rbp
movq 0xac8(%rdi), %r13
shlq $0x4, %r13
addq $0x6b8, %r13 # imm = 0x6B8
leaq 0x110(%rsi), %r15
movq 0x110(%rsi), %r12
cmpq %r15, %r12
je 0x73d7
movq %rsi, %r14
lea... | /ornladios[P]ADIOS2/thirdparty/enet/enet/protocol.c |
enet_protocol_notify_disconnect | static void
enet_protocol_notify_disconnect (ENetHost * host, ENetPeer * peer, ENetEvent * event)
{
if (peer -> state >= ENET_PEER_STATE_CONNECTION_PENDING)
host -> recalculateBandwidthLimits = 1;
if (peer -> state != ENET_PEER_STATE_CONNECTING && peer -> state < ENET_PEER_STATE_CONNECTION_SUCCEEDED)
... | movl 0x38(%rsi), %eax
cmpl $0x3, %eax
jb 0x7486
movl $0x1, 0x20(%rdi)
cmpl $0x1, %eax
sete %cl
cmpl $0x4, %eax
setae %al
orb %cl, %al
je 0x74ac
testq %rdx, %rdx
je 0x74b4
movl $0x2, (%rdx)
movq %rsi, 0x8(%rdx)
movl $0x0, 0x14(%rdx)
movq %rsi, %rdi
jmp 0x2080
movl $0x0, 0x1c8(%rsi)
movl $0x9, %edx
jmp 0x7425
| /ornladios[P]ADIOS2/thirdparty/enet/enet/protocol.c |
enet_protocol_handle_connect | static ENetPeer *
enet_protocol_handle_connect (ENetHost * host, ENetProtocolHeader * header, ENetProtocol * command)
{
enet_uint8 incomingSessionID, outgoingSessionID;
enet_uint32 mtu, windowSize;
ENetChannel * channel;
size_t channelCount, duplicatePeers = 0;
ENetPeer * currentPeer, * peer = NULL;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x12(%rsi), %r13d
bswapl %r13d
leal -0x100(%r13), %eax
cmpl $0xffffff01, %eax # imm = 0xFFFFFF01
jb 0x77d7
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x753f
movq 0x28(%r15), %rcx
xorl %ebx, %ebx
... | /ornladios[P]ADIOS2/thirdparty/enet/enet/protocol.c |
enet_protocol_remove_sent_reliable_command | static ENetProtocolCommand
enet_protocol_remove_sent_reliable_command (ENetPeer * peer, enet_uint16 reliableSequenceNumber, enet_uint8 channelID)
{
ENetOutgoingCommand * outgoingCommand = NULL;
ENetListIterator currentCommand;
ENetProtocolCommand commandNumber;
int wasSent = 1;
for (currentCommand ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xf0(%rdi), %r15
movq 0xf0(%rdi), %rax
cmpq %r15, %rax
sete %bpl
je 0x7937
movq %rax, %r14
cmpw %si, 0x10(%rax)
jne 0x7929
cmpb %dl, 0x29(%r14)
je 0x793a
movq (%r14), %rax
cmpq %r15, %rax
sete %bpl
jne 0x791a
jmp 0x793a
xorl %r14d, %r14d
testb ... | /ornladios[P]ADIOS2/thirdparty/enet/enet/protocol.c |
enet_protocol_notify_connect | static void
enet_protocol_notify_connect (ENetHost * host, ENetPeer * peer, ENetEvent * event)
{
host -> recalculateBandwidthLimits = 1;
if (event != NULL)
{
enet_protocol_change_state (host, peer, ENET_PEER_STATE_CONNECTED);
event -> type = ENET_EVENT_TYPE_CONNECT;
event -> peer =... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl $0x1, 0x20(%rdi)
testq %rdx, %rdx
je 0x7a64
movq %rdx, %r14
movq %rbx, %rdi
callq 0x2230
movl $0x5, 0x38(%rbx)
movl $0x1, (%r14)
movq %rbx, 0x8(%r14)
movl 0x1c8(%rbx), %eax
movl %eax, 0x14(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edx, %edx
cmpl $0x1, 0x3... | /ornladios[P]ADIOS2/thirdparty/enet/enet/protocol.c |
enet_address_set_host_ip | int
enet_address_set_host_ip (ENetAddress * address, const char * name)
{
#ifdef HAS_INET_PTON
if (! inet_pton (AF_INET, name, & address -> host))
#else
if (! inet_aton (name, (struct in_addr *) & address -> host))
#endif
return -1;
return 0;
} | pushq %rax
movq %rdi, %rdx
movl $0x2, %edi
callq 0x2240
xorl %ecx, %ecx
cmpl $0x1, %eax
sbbl %ecx, %ecx
movl %ecx, %eax
popq %rcx
retq
| /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_address_set_host | int
enet_address_set_host (ENetAddress * address, const char * name)
{
#ifdef HAS_GETADDRINFO
struct addrinfo hints, * resultList = NULL, * result = NULL;
memset (& hints, 0, sizeof (hints));
hints.ai_family = AF_INET;
if (getaddrinfo (name, NULL, NULL, & resultList) != 0)
return -1;
for (r... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rcx
movq $0x0, (%rcx)
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x23e0
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x7ba7
movq (%rsp), %rax
testq %rax, %rax
je 0x7b80
cmpl $0x2, 0x4(%rax)
jn... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_address_get_host_ip | int
enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength)
{
#ifdef HAS_INET_NTOP
if (inet_ntop (AF_INET, & address -> host, name, nameLength) == NULL)
#else
char * addr = inet_ntoa (* (struct in_addr *) & address -> host);
if (addr != NULL)
{
size_t addrLen = str... | pushq %rax
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movl $0x2, %edi
callq 0x2030
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, %eax
popq %rcx
retq
| /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_address_get_host | int
enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength)
{
#ifdef HAS_GETNAMEINFO
struct sockaddr_in sin;
int err;
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movw $0x2, (%rdi)
movzwl 0x4(%r12), %eax
rolw $0x8, %ax
movq %rsi, %r15
movw %ax, 0x2(%rdi)
movl (%r12), %eax
movl %eax, 0x4(%rdi)
movl $0x8, (%rsp)
xorl %ebx, %ebx
... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_bind | int
enet_socket_bind (ENetSocket socket, const ENetAddress * address)
{
struct sockaddr_in sin;
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
if (address != NULL)
{
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr = address -> hos... | subq $0x18, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movw $0x2, (%rsp)
testq %rsi, %rsi
je 0x7cbb
movzwl 0x4(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0x2(%rsp)
movl (%rsi), %eax
jmp 0x7cc4
movw $0x0, 0x2(%rsp)
xorl %eax, %eax
movq %rsp, %rsi
movl %eax, 0x4(%rsi)
movl $0x10, %edx
callq 0x2310
addq $0x18, %rsp
retq
| /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_get_address | int
enet_socket_get_address (ENetSocket socket, ENetAddress * address)
{
struct sockaddr_in sin;
socklen_t sinLength = sizeof (struct sockaddr_in);
if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1)
return -1;
address -> host = (enet_uint32) sin.sin_addr.s_addr;
address ... | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x10, (%rdx)
leaq 0x10(%rsp), %rsi
callq 0x2370
cmpl $-0x1, %eax
je 0x7d12
movl 0x14(%rsp), %eax
movl %eax, (%rbx)
movzwl 0x12(%rsp), %eax
rolw $0x8, %ax
movw %ax, 0x4(%rbx)
xorl %eax, %eax
jmp 0x7d17
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_set_option | int
enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value)
{
int result = -1;
switch (option)
{
case ENET_SOCKOPT_NONBLOCK:
#ifdef HAS_FCNTL
result = fcntl (socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl (socket, F_GETFL) & ~O_NONBLOCK));
#else
res... | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
decl %esi
cmpl $0x9, %esi
ja 0x7ea9
movl %edi, %ebx
leaq 0x13c2(%rip), %rcx # 0x9128
movslq (%rcx,%rsi,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
xorl %ebp, %ebp
testl %edx, %edx
setne %bpl
shll $0xb, %ebp
movl %eb... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_get_option | int
enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value)
{
int result = -1;
socklen_t len;
switch (option)
{
case ENET_SOCKOPT_ERROR:
len = sizeof (int);
result = getsockopt (socket, SOL_SOCKET, SO_ERROR, value, & len);
break;
... | pushq %rax
movq %rdx, %rcx
cmpl $0xa, %esi
je 0x7ee7
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x8, %esi
jne 0x7eff
leaq 0x4(%rsp), %r8
movl $0x4, (%r8)
movl $0x1, %esi
movl $0x4, %edx
jmp 0x7efa
leaq 0x4(%rsp), %r8
movl $0x4, (%r8)
xorl %esi, %esi
movl $0x2, %edx
callq 0x21f0
xorl %ecx, %ecx
cmpl $-0x1, %e... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_connect | int
enet_socket_connect (ENetSocket socket, const ENetAddress * address)
{
struct sockaddr_in sin;
int result;
memset (& sin, 0, sizeof (struct sockaddr_in));
sin.sin_family = AF_INET;
sin.sin_port = ENET_HOST_TO_NET_16 (address -> port);
sin.sin_addr.s_addr = address -> host;
result = co... | pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movw $0x2, (%rax)
movzwl 0x4(%rsi), %ecx
rolw $0x8, %cx
movw %cx, 0x2(%rax)
movl (%rsi), %ecx
movl %ecx, 0x4(%rax)
movq %rax, %rsi
movl $0x10, %edx
callq 0x23c0
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x7f54
callq 0x2090
movq %rax, %rcx
xo... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_accept | ENetSocket
enet_socket_accept (ENetSocket socket, ENetAddress * address)
{
int result;
struct sockaddr_in sin;
socklen_t sinLength = sizeof (struct sockaddr_in);
result = accept (socket,
address != NULL ? (struct sockaddr *) & sin : NULL,
address != NULL ? & ... | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0x4(%rsp), %rdx
movl $0x10, (%rdx)
testq %rsi, %rsi
sete %bpl
leaq 0x8(%rsp), %rsi
cmoveq %rbx, %rsi
cmoveq %rbx, %rdx
callq 0x2360
cmpl $-0x1, %eax
sete %cl
orb %bpl, %cl
jne 0x7fa7
movl 0xc(%rsp), %ecx
movl %ecx, (%rbx)
movzwl 0xa(%rsp), %ecx
rolw $0x8, %cx
... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_send | int
enet_socket_send (ENetSocket socket,
const ENetAddress * address,
const ENetBuffer * buffers,
size_t bufferCount)
{
struct msghdr msgHdr;
struct sockaddr_in sin;
int sentLength;
memset (& msgHdr, 0, sizeof (struct msghdr));
if (address != N... | subq $0x58, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
testq %rsi, %rsi
je 0x800d
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movw $0x2, (%rax)
movzwl 0x4(%rsi), %r8d
rolw $0x8, %r8w
movw %r8w, 0x2(%rax)
movl (%rsi), %esi
movl %esi, 0x4(%rax)
movq... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_receive | int
enet_socket_receive (ENetSocket socket,
ENetAddress * address,
ENetBuffer * buffers,
size_t bufferCount)
{
struct msghdr msgHdr;
struct sockaddr_in sin;
int recvLength;
memset (& msgHdr, 0, sizeof (struct msghdr));
if (address != N... | pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
testq %rsi, %rsi
je 0x8076
movq %rsp, %rax
movq %rax, 0x10(%rsp)
movl $0x10, 0x18(%rsp)
leaq 0x10(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movl $... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
enet_socket_wait | int
enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout)
{
#ifdef HAS_POLL
struct pollfd pollSocket;
int pollCount;
pollSocket.fd = socket;
pollSocket.events = 0;
if (* condition & ENET_SOCKET_WAIT_SEND)
pollSocket.events |= POLLOUT;
if (* condition & E... | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %rax
movl %edi, (%rax)
movw $0x0, 0x4(%rax)
movzwl (%rsi), %ecx
movl %ecx, %esi
andl $0x1, %esi
shrl %ecx
andl $0x1, %ecx
leal (%rcx,%rsi,4), %ecx
movw %cx, 0x4(%rax)
movl $0x1, %esi
movq %rax, %rdi
callq 0x2300
testl %eax, %eax
js 0x817d
movl %eax, %ecx
movl ... | /ornladios[P]ADIOS2/thirdparty/enet/enet/unix.c |
save_chromaticities | static exr_result_t
save_chromaticities (
struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_chromaticities_t tmp = *(a->chromaticities);
rv = save_attr_sz (ctxt, sizeof (exr_attr_chromaticities_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (c... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rsi
movl $0x20, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x1fe55
leaq 0x10(%rsp), %rsi
movl $... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_m33d | static exr_result_t
save_m33d (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_m33d_t tmp = *(a->m33d);
rv = save_attr_sz (ctxt, sizeof (exr_attr_m33d_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_64 (ctxt, &tmp, 9);
return rv;
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movl $0x48, %edx
callq 0x4260
leaq 0xc(%rsp), %rsi
movl $0x48, (%rsi)
leaq 0xb0(%rbx), %r14
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq *0x30(%rbx)
testl %eax, %eax
jne 0x20119
leaq 0x10(%rsp), %rsi
movl $0x48, %edx
movq %rbx, %rdi
m... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_m44f | static exr_result_t
save_m44f (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_m44f_t tmp = *(a->m44f);
rv = save_attr_sz (ctxt, sizeof (exr_attr_m44f_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (ctxt, &tmp, 16);
return rv;
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups 0x30(%rsi), %xmm3
movaps %xmm3, 0x40(%rsp)
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rsi
movl $0x40, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_m44d | static exr_result_t
save_m44d (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_m44d_t tmp = *(a->m44d);
rv = save_attr_sz (ctxt, sizeof (exr_attr_m44d_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_64 (ctxt, &tmp, 16);
return rv;
} | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x80, %edx
callq 0x4260
leaq 0x4(%rsp), %rsi
movl $0x80, (%rsi)
leaq 0xb0(%rbx), %r14
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq *0x30(%rbx)
testl %eax, %eax
jne 0x201dd
leaq 0x8(%rsp), %rsi
movl $0x80, %edx
movq %rbx, %rdi
mov... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_rational | static exr_result_t
save_rational (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_rational_t tmp = *(a->rational);
rv = save_attr_sz (ctxt, sizeof (exr_attr_rational_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (ctxt, &tmp, 2);
return rv;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movl $0x8, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x202cc
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq *0x30(%rbx)
addq $0x18, %rsp... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_string | static exr_result_t
save_string (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_string_t* tmp = a->string;
rv = save_attr_sz (ctxt, (size_t) tmp->length);
if (rv == EXR_ERR_SUCCESS)
rv = ctxt->do_write (
ctxt,
tmp->str,
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
testl %eax, %eax
js 0x202ff
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
leaq 0xb0(%rbx), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq *0x30(%rbx)
jmp 0x2030a
movq %rbx, %rdi
movl $0x3, %esi
callq *0x38(%rbx)
testl %eax, %eax
jne 0x20322
movq 0x... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_string_vector | static exr_result_t
save_string_vector (
struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
size_t attrsz = 0;
for (int i = 0; i < a->stringvector->n_strings; ++i)
{
attrsz += sizeof (int32_t);
attrsz += (size_t) a->stringvector->strings[i].length... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x18(%rsi), %rax
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x20383
movq 0x8(%rax), %rdx
shlq $0x4, %rcx
xorl %esi, %esi
xorl %eax, %eax
movslq (%rdx,%rsi), %rdi
addq %rdi, %rax
addq $0x4, %rax
add... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_tiledesc | static exr_result_t
save_tiledesc (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
uint32_t sizes[2];
sizes[0] = a->tiledesc->x_size;
sizes[1] = a->tiledesc->y_size;
rv = save_attr_sz (ctxt, sizeof (uint32_t) * 2 + 1);
if (rv == EXR_ERR_SUCCESS) rv = save_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %rax
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0xc(%rsp), %rsi
movl $0x9, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x2049c
movq %rsp, %rsi
movl $0x8, %edx
movq %rb... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_timecode | static exr_result_t
save_timecode (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_timecode_t tmp = *(a->timecode);
rv = save_attr_sz (ctxt, sizeof (exr_attr_timecode_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (ctxt, &tmp, 2);
return rv;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movl $0x8, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x204e9
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq *0x30(%rbx)
addq $0x18, %rsp... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_v2i | static exr_result_t
save_v2i (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_v2i_t tmp = *(a->v2i);
rv = save_attr_sz (ctxt, sizeof (exr_attr_v2i_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (ctxt, &tmp, 2);
return rv;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movl $0x8, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x20534
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq *0x30(%rbx)
addq $0x18, %rsp... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_v2f | static exr_result_t
save_v2f (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_v2f_t tmp = *(a->v2f);
rv = save_attr_sz (ctxt, sizeof (exr_attr_v2f_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (ctxt, &tmp, 2);
return rv;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movl $0x8, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x2057f
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq *0x30(%rbx)
addq $0x18, %rsp... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_v3i | static exr_result_t
save_v3i (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_v3i_t tmp = *(a->v3i);
rv = save_attr_sz (ctxt, sizeof (exr_attr_v3i_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (ctxt, &tmp, 3);
return rv;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x10(%rsp)
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movl $0xc, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x20622
leaq 0x8(%rsp), %rsi
movl $0xc, %edx
movq ... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_v3f | static exr_result_t
save_v3f (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
exr_attr_v3f_t tmp = *(a->v3f);
rv = save_attr_sz (ctxt, sizeof (exr_attr_v3f_t));
if (rv == EXR_ERR_SUCCESS) rv = save_attr_32 (ctxt, &tmp, 3);
return rv;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x10(%rsp)
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
movl $0xc, (%rsi)
leaq 0xb0(%rdi), %r14
movl $0x4, %edx
movq %r14, %rcx
callq *0x30(%rdi)
testl %eax, %eax
jne 0x20677
leaq 0x8(%rsp), %rsi
movl $0xc, %edx
movq ... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
save_opaque | static exr_result_t
save_opaque (struct _internal_exr_context* ctxt, const exr_attribute_t* a)
{
exr_result_t rv;
int32_t sz = 0;
void* pdata = NULL;
rv =
exr_attr_opaquedata_pack ((exr_context_t) ctxt, a->opaque, &sz, &pdata);
if (rv != EXR_ERR_SUCCESS) return rv;
rv = ... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x10(%rsp), %rcx
movq $0x0, (%rcx)
callq 0x12ac7
testl %eax, %eax
jne 0x20758
movl 0xc(%rsp), %eax
testl %eax, %eax
js 0x20721
leaq 0x1c(%rsp), %rsi
movl %eax, (%rsi)
leaq 0xb0(%rbx), %rcx
movl $0x4, %edx
movq %rbx, %rdi
callq *0x30... | /meshula[P]openexr/src/lib/OpenEXRCore/write_header.c |
exr_read_scanline_chunk_info | exr_result_t
exr_read_scanline_chunk_info (
exr_const_context_t ctxt, int part_index, int y, exr_chunk_info_t* cinfo)
{
exr_result_t rv;
int miny, cidx, rdcnt, lpc;
int32_t data[3];
int64_t ddata[3];
int64_t fsize;
uint64_t chunkmin, dataof... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rdi, %rdi
je 0x20797
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x207ad
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x7, %esi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl $0x2, %ecx
movl %... | /meshula[P]openexr/src/lib/OpenEXRCore/chunk.c |
extract_chunk_table | static exr_result_t
extract_chunk_table (
const struct _internal_exr_context* ctxt,
const struct _internal_exr_part* part,
uint64_t** chunktable,
uint64_t* chunkminoffset)
{
uint64_t* ctable = NULL;
uint64_t chunkoff = part->chunk_tabl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq 0xf8(%rsi), %rax
movq %rax, 0x8(%rsp)
movslq 0xf4(%rsi), %r13
leaq (%rax,%r13,8), %rax
movq %rax, (%rcx)
movq 0x100(%rsi), %r12
testq %r12, %r12
je 0x20c43
movq %r12, (%r14)
xorl %ebp, %ebp
jmp 0x20ce7
movq %rsi, %r1... | /meshula[P]openexr/src/lib/OpenEXRCore/chunk.c |
exr_write_scanline_chunk_info | exr_result_t
exr_write_scanline_chunk_info (
exr_context_t ctxt, int part_index, int y, exr_chunk_info_t* cinfo)
{
exr_attr_box2i_t dw;
int lpc, miny, cidx;
exr_chunk_info_t nil = {0};
EXR_PROMOTE_LOCKED_CONTEXT_AND_PART_OR_ERROR (ctxt, part_index);
if (!cinfo)
return EXR_... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x21c44
movq %rcx, %rbx
movl %esi, %ecx
testl %esi, %esi
js 0x21c2b
cmpl %ecx, 0xc4(%rdi)
jle 0x21c2b
testq %rbx, %rbx
je 0x21c4e
movq 0x1d8(%rdi), %rax
movl %ecx, %ecx
movq (%rax,%rcx,8), %r8
movl 0x4(%r8), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x21c5d
movq 0x38(%... | /meshula[P]openexr/src/lib/OpenEXRCore/chunk.c |
exr_write_deep_scanline_chunk | exr_result_t
exr_write_deep_scanline_chunk (
exr_context_t ctxt,
int part_index,
int y,
const void* packed_data,
uint64_t packed_size,
uint64_t unpacked_size,
const void* sample_data,
uint64_t sample_data_size)
{
exr_result_t rv;
EXR_PROMOTE... | testq %rdi, %rdi
je 0x224a8
movq %r9, %rax
movq %r8, %r9
movq %rcx, %r8
movl %esi, %ecx
testl %esi, %esi
js 0x22493
cmpl %ecx, 0xc4(%rdi)
jle 0x22493
movl %edx, %r10d
movq 0x1d8(%rdi), %rdx
movl %ecx, %esi
movq (%rdx,%rsi,8), %rdx
cmpl $0x0, 0x4(%rdx)
je 0x224ae
pushq %rax
subq $0x8, %rsp
movl %ecx, %esi
movl %r10d, %e... | /meshula[P]openexr/src/lib/OpenEXRCore/chunk.c |
write_tile_chunk | static exr_result_t
write_tile_chunk (
struct _internal_exr_context* pctxt,
int part_index,
struct _internal_exr_part* part,
int tilex,
int tiley,
int levelx,
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x3, %eax
je 0x22577
cmpl $0x1, %eax
jne 0x22592
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x9, %esi
jmp 0x2259e
movq %rdx, %r14
movl 0x4(%rdx), %eax
testl $0xfffffffd, %eax # imm = 0xFFF... | /meshula[P]openexr/src/lib/OpenEXRCore/chunk.c |
internal_validate_next_chunk | exr_result_t
internal_validate_next_chunk (
exr_encode_pipeline_t* encode,
const struct _internal_exr_context* pctxt,
const struct _internal_exr_part* part)
{
exr_result_t rv = EXR_ERR_SUCCESS;
int cidx, lpc;
if (pctxt->cur_output_part != encode->part_index)
ret... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0xb8(%rsi), %eax
cmpl 0xc(%rdi), %eax
jne 0x229ef
movq %rdx, %r14
movq %rdi, %r15
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
movl 0x4(%rdx), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0x22a06
movl 0x1c(%r15), %edx
movl 0x20(%r15), %ecx
movzbl 0x2c... | /meshula[P]openexr/src/lib/OpenEXRCore/chunk.c |
alloc_chunk_table | static exr_result_t
alloc_chunk_table (
const struct _internal_exr_context* ctxt,
const struct _internal_exr_part* part,
uint64_t** chunktable)
{
uint64_t* ctable = NULL;
/* we have the lock, but to access the type, we'll use the atomic function anyway */
#if defined(_MS... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq 0x100(%rsi), %r15
testq %r15, %r15
je 0x22f01
movq %r15, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rsi, %r12
movq %rdi, %r14
movslq 0xf4(%rsi), %r13
shlq $0x3, %r13
movq %r13, %rdi
callq *0x58(%r14)
tes... | /meshula[P]openexr/src/lib/OpenEXRCore/chunk.c |
default_decompress_chunk | static exr_result_t
default_decompress_chunk (exr_decode_pipeline_t* decode)
{
exr_result_t rv = EXR_ERR_SUCCESS;
EXR_PROMOTE_READ_CONST_CONTEXT_AND_PART_OR_ERROR (
decode->context, decode->part_index);
if (part->storage_mode == EXR_STORAGE_DEEP_SCANLINE ||
part->storage_mode == EXR_STORAGE... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x23fd1
cmpb $0x0, (%rbx)
je 0x23fe2
movq 0x38(%rbx), %rax
movq %rbx, %rdi
movl $0x7, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
pop... | /meshula[P]openexr/src/lib/OpenEXRCore/decoding.c |
update_pack_unpack_ptrs | OPENEXR_CORE_INTERNAL_NAMESPACE_SOURCE_ENTER
/**************************************/
static exr_result_t
update_pack_unpack_ptrs (exr_decode_pipeline_t* decode)
{
exr_result_t rv;
exr_storage_t stortype = ((exr_storage_t) decode->chunk.type);
if (stortype == EXR_STORAGE_DEEP_SCANLINE ||
stortyp... | pushq %rbx
movq %rdi, %rbx
movb 0x2e(%rdi), %al
andb $-0x2, %al
cmpb $0x2, %al
jne 0x2441b
movslq 0x28(%rbx), %rax
movslq 0x24(%rbx), %rcx
imulq %rax, %rcx
movzwl 0xa(%rbx), %r8d
andl $0x1, %r8d
addq %rcx, %r8
shlq $0x2, %r8
leaq 0x90(%rbx), %rdx
leaq 0x98(%rbx), %rcx
cmpq %r8, 0x50(%rbx)
jne 0x24402
movq %rbx, %rdi
mo... | /meshula[P]openexr/src/lib/OpenEXRCore/decoding.c |
default_compress_chunk | OPENEXR_CORE_INTERNAL_NAMESPACE_SOURCE_ENTER
/**************************************/
static exr_result_t
default_compress_chunk (exr_encode_pipeline_t* encode)
{
exr_result_t rv;
EXR_PROMOTE_CONST_CONTEXT_AND_PART_OR_ERROR_NO_LOCK (
encode->context, encode->part_index);
rv = internal_encode_allo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x24a86
movq %rdi, %r14
movslq 0xc(%rdi), %rcx
testq %rcx, %rcx
js 0x24a60
cmpl 0xc4(%rbx), %ecx
jge 0x24a60
movq 0x1d8(%rbx), %rax
movq (%rax,%rcx,8), %r13
leaq 0xa0(%r14), %r15
leaq 0xb0(%r14), %r12
... | /meshula[P]openexr/src/lib/OpenEXRCore/encoding.c |
default_write_chunk | static exr_result_t
default_write_chunk (exr_encode_pipeline_t* encode)
{
exr_result_t rv;
if (!encode) return EXR_ERR_INVALID_ARGUMENT;
switch (encode->chunk.type)
{
case EXR_STORAGE_SCANLINE:
rv = exr_write_scanline_chunk (
EXR_CONST_CAST (exr_context_t, encode->c... | subq $0x28, %rsp
testq %rdi, %rdi
je 0x24ce3
movzbl 0x2e(%rdi), %eax
cmpq $0x3, %rax
ja 0x24ce3
leaq 0x1eb8d4(%rip), %rcx # 0x2104e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rdi), %rax
movl 0xc(%rdi), %esi
movl 0x20(%rdi), %edx
movq 0xa0(%rdi), %rcx
movq 0xa8(%rdi), %r8
movq %rax, %rdi
addq $... | /meshula[P]openexr/src/lib/OpenEXRCore/encoding.c |
internal_exr_match_decode | internal_exr_unpack_fn
internal_exr_match_decode (
exr_decode_pipeline_t* decode,
int isdeep,
int chanstofill,
int chanstounpack,
int sametype,
int sameouttype,
int samebpc,
... | cmpb $0x0, 0x1f5f25(%rip) # 0x21b6a8
jne 0x2578c
movb $0x1, 0x1f5f1c(%rip) # 0x21b6a8
testl %esi, %esi
je 0x257a7
testb $0x1, 0xa(%rdi)
leaq 0x74e(%rip), %rcx # 0x25ee9
leaq 0x16c(%rip), %rax # 0x2590e
cmoveq %rcx, %rax
retq
movl 0x38(%rsp), %esi
movl 0x30(%rsp), %r10d
movl 0x28(%rsp), %ecx
cmpl $0x0,... | /meshula[P]openexr/src/lib/OpenEXRCore/unpack.c |
unpack_16bit_4chan_interleave | static exr_result_t
unpack_16bit_4chan_interleave (exr_decode_pipeline_t* decode)
{
/* we know we're unpacking all the channels and there is no subsampling */
const uint8_t* srcbuffer = (const uint8_t*) decode->unpacked_buffer;
const uint16_t *in0, *in1, *in2, *in3;
uint8_t* out0;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x24(%rdi), %eax
movl %eax, -0x4(%rsp)
testl %eax, %eax
jle 0x27579
movq (%rdi), %r8
movq 0x70(%rdi), %rcx
movl 0xc(%r8), %edx
movq 0x28(%r8), %rsi
movslq 0x24(%r8), %rdi
movslq %edx, %r11
leal (,%r11,8), %r8d
movslq %r8d, %r8
leaq (%r11,%r11,2), %r... | /meshula[P]openexr/src/lib/OpenEXRCore/unpack.c |
unpack_16bit_3chan_interleave_rev | static exr_result_t
unpack_16bit_3chan_interleave_rev (exr_decode_pipeline_t* decode)
{
/* we know we're unpacking all the channels and there is no subsampling */
const uint8_t* srcbuffer = (const uint8_t*) decode->unpacked_buffer;
const uint16_t *in0, *in1, *in2;
uint8_t* out0;
int ... | movl 0x24(%rdi), %eax
testl %eax, %eax
jle 0x27738
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r8
movq 0x70(%rdi), %rcx
movl 0xc(%r8), %edx
movslq %edx, %rsi
movq 0x88(%r8), %rdi
movslq 0x24(%r8), %r8
leaq (%rsi,%rsi), %r9
leaq (%r9,%r9,2), %r9
movq %rdx, %r10
addq %rdx, %r10
leaq (%r10,%r10,2), %r10
xorl %r11d, %r1... | /meshula[P]openexr/src/lib/OpenEXRCore/unpack.c |
unpack_16bit_4chan | static exr_result_t
unpack_16bit_4chan (exr_decode_pipeline_t* decode)
{
/* we know we're unpacking all the channels and there is no subsampling */
const uint8_t* srcbuffer = (const uint8_t*) decode->unpacked_buffer;
const uint16_t *in0, *in1, *in2, *in3;
uint8_t * out0, *out1, *out2, *out3;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x24(%rdi), %eax
movl %eax, -0x44(%rsp)
testl %eax, %eax
jle 0x27a9e
movq (%rdi), %rsi
movq 0x70(%rdi), %rcx
movl 0xc(%rsi), %edx
movslq 0xb0(%rsi), %rax
movq %rax, -0x30(%rsp)
movslq 0x80(%rsi), %rdi
movslq 0x50(%rsi), %r8
movslq 0x20(%rsi), %r9
mo... | /meshula[P]openexr/src/lib/OpenEXRCore/unpack.c |
unpack_16bit_3chan | static exr_result_t
unpack_16bit_3chan (exr_decode_pipeline_t* decode)
{
/* we know we're unpacking all the channels and there is no subsampling */
const uint8_t* srcbuffer = (const uint8_t*) decode->unpacked_buffer;
const uint16_t *in0, *in1, *in2;
uint8_t * out0, *out1, *out2;
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x24(%rdi), %eax
movl %eax, -0x1c(%rsp)
testl %eax, %eax
jle 0x27b9e
movq (%rdi), %rax
movq 0x70(%rdi), %rcx
movl 0xc(%rax), %edx
movslq 0x80(%rax), %rsi
movslq 0x50(%rax), %rdi
movslq 0x20(%rax), %r8
movq 0x88(%rax), %r9
movq 0x58(%rax), %r10
movq ... | /meshula[P]openexr/src/lib/OpenEXRCore/unpack.c |
unpack_32bit | static exr_result_t
unpack_32bit (exr_decode_pipeline_t* decode)
{
/* we know we're unpacking all the channels and there is no subsampling */
const uint8_t* srcbuffer = (const uint8_t*) decode->unpacked_buffer;
uint8_t* cdata;
int64_t w, h, pixincrement;
int chans = decode->c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x24(%rdi), %rax
movq %rax, (%rsp)
testq %rax, %rax
jle 0x27d04
movq %rdi, %rbx
movswq 0x8(%rdi), %r12
movq 0x70(%rdi), %r14
xorl %r13d, %r13d
testw %r12w, %r12w
jle 0x27cfb
xorl %ebp, %ebp
movq (%rbx), %rcx
leaq (,%rbp,2), %rdx
addq %r... | /meshula[P]openexr/src/lib/OpenEXRCore/unpack.c |
KDopTest_testoverlappedNeg_Test::KDopTest_testoverlappedNeg_Test() | TEST(KDopTest, testoverlappedNeg)
{
TVertices triangle1 =
{
{3, 1, 0},
{1, 5, 0},
{5, 4, 0}
};
TVertices triangle2 =
{
{4, 1, 0},
{5, 2, 0},
{7, 1, 0}
};
KDop<16> bv1;
for (unsigned i = 0; i < 3; ++i)
{
bv1 += triangle1[i];
... | pushq %rbx
movq %rdi, %rbx
callq 0x27b2a
leaq 0x277de(%rip), %rax # 0x4b040
movq %rax, (%rbx)
popq %rbx
retq
nop
| /valbok[P]bvh3/bvh3/bv/tests/KDopTest.cpp |
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
return gtest_msg + "\n" + user_m... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x25720
cmpq $0x0, 0x8(%r15)
je 0x243ff
leaq 0x16c5a(%rip), %rdx # 0x3b034
movq %rsp, %rdi
movq %r14, %rsi
callq 0x31a98
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
const FilePath& base_name,
const char* extension) {
FilePath full_pathname;
int number = 0;
do {
full_pathname.Set(MakeFileName(directory, base_name, number+... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x31a36
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
callq 0x301f2
movq %rbx, %rdi
movq %r13, %r... | /valbok[P]bvh3/lib/gtest/src/gtest-filepath.cc |
testing::internal::HasOneFailure(char const*, char const*, char const*, testing::TestPartResultArray const&, testing::TestPartResult::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult HasOneFailure(const char* /* results_expr */,
const char* /* type_expr */,
const char* /* substr_expr */,
const TestPartResultArray& results,
TestPartResult::Type type,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r9d, %ebp
movq %r8, %r14
movq %rdi, %rbx
cmpl $0x2, %r9d
leaq 0x15a4f(%rip), %rax # 0x3a8dc
leaq 0x15a58(%rip), %rsi # 0x3a8ec
cmoveq %rax, %rsi
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x201a0
leaq 0x8(%rsp), %rdi
callq 0x25... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | Message& Message::operator <<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
xorl %r13d, %r13d
movq %rsp, %r14
cmpq %r13, %r12
je 0x256fc
cmpl $0x0, (%r15,%r13,4)
je 0x256e3
leaq (%r15,%r13,4), %rsi
movl %r12d, %edx
subl %r13d, %edx
movq %r14, %rdi
callq 0x270a4
movq %r... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::EqFailure(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | AssertionResult EqFailure(const char* expected_expression,
const char* actual_expression,
const std::string& expected_value,
const std::string& actual_value,
bool ignoring_case) {
Message msg;
msg << "Value of: "... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x25560
movq (%r12), %rdi
addq $0x10, %rdi
leaq 0x15022(%rip), %rsi # 0x3a923
callq 0x20400
le... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::CmpHelperEQ(char const*, char const*, long long, long long) | AssertionResult CmpHelperEQ(const char* expected_expression,
const char* actual_expression,
BiggestInt expected,
BiggestInt actual) {
if (expected == actual) {
return AssertionSuccess();
}
return EqFailure(expected_expression... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq %r8, %rcx
jne 0x25d37
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x25d88
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x36e8f
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x36e... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::CodePointToUtf8[abi:cxx11](unsigned int) | std::string CodePointToUtf8(UInt32 code_point) {
if (code_point > kMaxCodePoint4) {
return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")";
}
char str[5]; // Big enough for the largest valid code point.
if (code_point <= kMaxCodePoint1) {
str[1] = '\0';
str[0] = static_cast<char>(co... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x200000, %esi # imm = 0x200000
jb 0x26f62
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2702c
leaq 0x13af0(%rip), %rsi # 0x3aa1b
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x327c6
leaq 0x13f4c(%rip), %rdx # 0x3ae8b
leaq 0x8(%rsp), %rsi
movq %... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::Test::RecordProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void Test::RecordProperty(const std::string& key, int value) {
Message value_message;
value_message << value;
RecordProperty(key, value_message.GetString().c_str());
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x25560
movq (%r14), %r14
leaq 0x10(%r14), %rdi
movl %ebp, %esi
callq 0x20870
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x25731
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::TestInfo::Run() | void TestInfo::Run() {
if (!should_run_) return;
// Tells UnitTest where to store test result.
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_info(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Notifies the unit test even... | cmpb $0x1, 0x58(%rdi)
jne 0x2885c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x31ad0
movq %rax, %r14
movq %rbx, 0x110(%rax)
callq 0x24054
movq 0x23f2b(%rip), %rax # 0x4c6d8
movq 0x190(%rax), %r15
movq (%r15), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x38(%rax)
callq 0x25503
movq... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
ColoredPrintf(COLOR_GREEN, "[==========] ");
printf("%s from %s ran.",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestCaseCo... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x11638(%rip), %rsi # 0x3af94
pushq $0x2
popq %rdi
xorl %eax, %eax
callq 0x28cef
movq %rbx, %rdi
callq 0x29466
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x29449
movq (%r14), %r14
movq %rbx, %rdi
callq 0x2948c
leaq 0x2... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* xmlout = NULL;
FilePath output_file(output_file_);
FilePath output_dir(output_file.RemoveFileName());
if (output_dir.CreateDirectoriesRecursively()) {
xm... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
movq %rsi, %rbx
movq %rdi, %r15
addq $0x8, %r15
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x31a4a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2a10e
leaq 0x8(%rsp), %rdi
callq 0x2a1bc
testb %al, %al
je 0x2a0ab
movq (%r15), %rd... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::EscapeXml(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | std::string XmlUnitTestResultPrinter::EscapeXml(
const std::string& str, bool is_attribute) {
Message m;
for (size_t i = 0; i < str.size(); ++i) {
const char ch = str[i];
switch (ch) {
case '<':
m << "<";
break;
case '>':
m << ">";
break;
case '&'... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x25560
xorl %r12d, %r12d
leaq 0x10a24(%rip), %rbx # 0x3b0f0
leaq 0x18(%rsp), %r13
cmpq 0x8(%r14), %r12
jae 0x2a831
movq (%r14), %rax
movzbl (%rax,%r12)... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
const std::string& str) {
std::string output;
output.reserve(str.size());
for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
if (IsValidXmlCharacter(*it))
output.push_back(*it);
return output;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
callq 0x207a0
movq (%r14), %rax
movl $0x2600, %ebp # imm = 0x2600
movq %rax, %r15
movq 0x8(%r14), %rcx
addq %rax, %rcx
... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlCDataSection(std::ostream*, char const*) | void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
const char* data) {
const char* segment = data;
*stream << "<![CDATA[";
for (;;) {
const char* const next_segment = strstr(segment, "]]>");
if (next_segment != NULL) {
st... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x103f9(%rip), %rsi # 0x3b11f
callq 0x20400
leaq 0x103e0(%rip), %r15 # 0x3b112
leaq 0x103dd(%rip), %r12 # 0x3b116
movq %r14, %rdi
movq %r15, %rsi
callq 0x200d0
testq %rax, %rax
je 0x2ad71
movq %rax, %r13
movq %rax, %... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::OutputXmlTestInfo(std::ostream*, char const*, testing::TestInfo const&) | void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
const char* test_case_name,
const TestInfo& test_info) {
const TestResult& result = *test_info.result();
const std::string kTestcase = "testcase"... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x102a3(%rip), %rsi # 0x3b1c0
leaq 0xa0(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x201a0
leaq 0x10285(%rip), %rsi # 0x3b1bb
movq %rbx, %rdi
callq 0x20400
leaq 0x102b3(%rip)... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes[abi:cxx11](testing::TestResult const&) | std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x25560
xorl %ebp, %ebp
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %rbx
movq 0x58(%r14), %rax
subq 0x50(%r14), %rax
shrq $0x6, %rax
cmpl %eax, %ebp
jge 0x2b56c
movq %r14, %rdi... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener*) | void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
if (default_xml_generator_ != listener) {
// It is an error to pass this method a listener that is already in the
// list.
delete Release(default_xml_generator_);
default_xml_generator_ = listener;
if (listener != NULL)... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %rsi
cmpq %rbx, %rsi
je 0x2bf43
movq %rdi, %r14
callq 0x2be96
testq %rax, %rax
je 0x2bf28
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movq %rbx, 0x10(%r14)
testq %rbx, %rbx
je 0x2bf43
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq ... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::UnitTestImpl::ConfigureXmlOutput() | void UnitTestImpl::ConfigureXmlOutput() {
const std::string& output_format = UnitTestOptions::GetOutputFormat();
if (output_format == "xml") {
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (output_format != "") {
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x24554
leaq 0xebab(%rip), %rsi # 0x3b3e0
movq %rbx, %rdi
callq 0x33b57
testb %al, %al
je 0x2c886
pushq $0x28
popq %rdi
callq 0x20420
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x245ba
movb $0x1, %bpl
movq 0x20... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::UnitTestImpl::ShuffleTests() | void UnitTestImpl::ShuffleTests() {
// Shuffles the death test cases.
ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_);
// Shuffles the non-death test cases.
ShuffleRange(random(), last_death_test_case_ + 1,
static_cast<int>(test_cases_.size()), &test_case_indices_);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b8(%rdi), %r14
movl 0x104(%rdi), %edx
incl %edx
leaq 0xd0(%rdi), %r15
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x33e78
movl 0x104(%rbx), %esi
incl %esi
movq 0xc0(%rbx), %rdx
subq 0xb8(%rbx), %rdx
shrq $0x3, %rd... | /valbok[P]bvh3/lib/gtest/src/gtest.cc |
testing::internal::ParseInt32(testing::Message const&, char const*, int*) | bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
// Parses the environment variable as a decimal integer.
char* end = NULL;
const long long_value = strtol(str, &end, 10); // NOLINT
// Has strtol() consumed all characters in the string?
if (*end != '\0') {
// No - an invalid char... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
leaq 0x38(%rsp), %r15
andq $0x0, (%r15)
pushq $0xa
popq %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x206d0
movq (%r15), %rcx
cmpb $0x0, (%rcx)
je 0x2d10e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x25560
movq (%r14)... | /valbok[P]bvh3/lib/gtest/src/gtest-port.cc |
testing::internal::ParseStringFlag(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == NULL) return false;
// Sets *value to the value of the flag.
*value = v... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %edx, %edx
callq 0x2d30f
movq %rax, %r14
testq %rax, %rax
je 0x2d4e2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20960
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /valbok[P]bvh3/lib/gtest/src/gtest.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.