name string | code string | asm string | file string |
|---|---|---|---|
readwrite_routine(void*) | static void *readwrite_routine( void *arg )
{
co_enable_hook_sys();
stEndPoint *endpoint = (stEndPoint *)arg;
char str[8]="sarlmol";
char buf[ 1024 * 16 ];
int fd = -1;
int ret = 0;
for(;;)
{
if ( fd < 0 )
{
fd = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr;
SetAddr(endpoint->ip, endp... | pushq %rbp
movq %rsp, %rbp
subq $0x4050, %rsp # imm = 0x4050
movq %rdi, -0x8(%rbp)
callq 0x8000
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x6722(%rip), %rax # 0xc025
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x4024(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x4028(%rbp)
cmpl $0x0, -0x4024(%rbp)
jge 0x5... | /abhinavabcd[P]libco/example_echocli.cpp |
SetAddr(char const*, unsigned short, sockaddr_in&) | static void SetAddr(const char *pszIP,const unsigned short shPort,struct sockaddr_in &addr)
{
bzero(&addr,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(shPort);
int nIP = 0;
if( !pszIP || '\0' == *pszIP
|| 0 == strcmp(pszIP,"0") || 0 == strcmp(pszIP,"0.0.0.0")
|| 0 == strcmp(pszIP,"*") ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x50e0
movq -0x18(%rbp), %rax
movw $0x2, (%rax)
movzwl -0xa(%rbp), %edi
callq 0x5050
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x... | /abhinavabcd[P]libco/example_echocli.cpp |
set_timeouts(int, int, int) | void set_timeouts(int fd , int read_timeout_secs, int write_timeout_secs){
rpchook_t * lp = get_by_fd( fd );
if(lp){
if(read_timeout_secs!=-1)//do not change
lp->read_timeout.tv_sec = read_timeout_secs;
if(write_timeout_secs!=-1)
lp->write_timeout.tv_sec = write_timeout_secs;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
callq 0x5c40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5c3a
cmpl $-0x1, -0x8(%rbp)
je 0x5c26
movslq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $-0x1, -0xc(... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
alloc_by_fd(int) | static inline rpchook_t * alloc_by_fd( int fd )
{
if( fd > -1 && fd < (int)sizeof(g_rpchook_socket_fd) / (int)sizeof(g_rpchook_socket_fd[0]) )
{
rpchook_t *lp = (rpchook_t*)calloc( 1,sizeof(rpchook_t) );
lp->read_timeout.tv_sec = 40;
lp->write_timeout.tv_sec = 10;
g_rpchook_socket_fd[ fd ] = lp;
return lp;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jle 0x5de2
cmpl $0xf4240, -0xc(%rbp) # imm = 0xF4240
jge 0x5de2
movl $0x1, %edi
movl $0x38, %esi
callq 0x5100
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x28, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0xa, 0x28(%rax)
movq... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
fcntl | int fcntl(int fildes, int cmd, ...)
{
HOOK_SYS_FUNC( fcntl );
if( fildes < 0 )
{
return __LINE__;
}
va_list arg_list;
va_start( arg_list,cmd );
int ret = -1;
rpchook_t *lp = get_by_fd( fildes );
switch( cmd )
{
case F_DUPFD:
{
int param = va_arg(arg_list,int);
ret = g_sys_fcntl_func( fildes,cmd... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
testb %al, %al
je 0x5e44
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %r9, -0xf8(%... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
co_accept(int, sockaddr*, unsigned int*) | int co_accept( int fd, struct sockaddr *addr, socklen_t *len )
{
HOOK_SYS_FUNC( fcntl );
int cli = accept( fd,addr,len );
if( cli < 0 )
{
return cli;
}
rpchook_t *lp = alloc_by_fd( cli );
int current_flags = g_sys_fcntl_func( cli ,F_GETFL, 0 );
int flag = current_flags;
flag |= O_NONBLOCK;
int ret = g_s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x9e9d(%rip) # 0x101f8
jne 0x6377
movq $-0x1, %rdi
leaq 0x5d3a(%rip), %rsi # 0xc0a5
callq 0x5180
movq %rax, 0x9e81(%rip) # 0x101f8
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
connect | int connect(int fd, const struct sockaddr *address, socklen_t address_len)
{
HOOK_SYS_FUNC( connect );
if( !co_is_enable_sys_hook() )
{
return g_sys_connect_func(fd,address,address_len);
}
//1.sys call
int ret = g_sys_connect_func( fd,address,address_len );
rpchook_t *lp = get_by_fd( fd );
if( !lp ) return... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, 0x9d7e(%rip) # 0x101a8
jne 0x6446
movq $-0x1, %rdi
leaq 0x5c2d(%rip), %rsi # 0xc067
callq 0x5180
movq %rax, 0x9d62(%rip) # 0x101a8
callq 0xafb0
testb $0x1, %al
jne 0x646a
movq 0x9d52... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
poll | int poll(struct pollfd fds[], nfds_t nfds, int timeout)
{
HOOK_SYS_FUNC( poll );
if (!co_is_enable_sys_hook() || timeout == 0) {
return g_sys_poll_func(fds, nfds, timeout);
}
pollfd *fds_merge = NULL;
nfds_t nfds_merge = 0;
std::map<int, int> m; // fd --> idx
std::map<int, int>::iterator it;
if (nfds > 1) {... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, 0x9bca(%rip) # 0x101e8
jne 0x663a
movq $-0x1, %rdi
leaq 0x5aa9(%rip), %rsi # 0xc0d7
callq 0x5180
movq %rax, 0x9bae(%rip) # 0x101e8
callq 0xafb0
testb $0x1,... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
close | int close(int fd)
{
HOOK_SYS_FUNC( close );
if( !co_is_enable_sys_hook() )
{
return g_sys_close_func( fd );
}
free_by_fd( fd );
int ret = g_sys_close_func(fd);
return ret;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpq $0x0, 0x97fd(%rip) # 0x101b0
jne 0x69cf
movq $-0x1, %rdi
leaq 0x56ac(%rip), %rsi # 0xc06f
callq 0x5180
movq %rax, 0x97e1(%rip) # 0x101b0
callq 0xafb0
testb $0x1, %al
jne 0x69e9
movq 0x97d1(%rip), %rax # 0x101b0
movl -0x8(%rbp), %... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
free_by_fd(int) | static inline void free_by_fd( int fd )
{
if( fd > -1 && fd < (int)sizeof(g_rpchook_socket_fd) / (int)sizeof(g_rpchook_socket_fd[0]) )
{
rpchook_t *lp = g_rpchook_socket_fd[ fd ];
if( lp )
{
g_rpchook_socket_fd[ fd ] = NULL;
free(lp);
}
}
return;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $-0x1, -0x4(%rbp)
jle 0x6a62
cmpl $0xf4240, -0x4(%rbp) # imm = 0xF4240
jge 0x6a62
movslq -0x4(%rbp), %rcx
leaq 0x981b(%rip), %rax # 0x10250
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6a60
movslq -0x4(%rbp), %... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
read | ssize_t read( int fd, void *buf, size_t nbyte )
{
HOOK_SYS_FUNC( read );
if( !co_is_enable_sys_hook() )
{
return g_sys_read_func( fd,buf,nbyte );
}
rpchook_t *lp = get_by_fd( fd );
if( !lp || ( O_NONBLOCK & lp->user_flag ) )
{
ssize_t ret = g_sys_read_func( fd,buf,nbyte );
return ret;
}
int timeout =... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, 0x972d(%rip) # 0x101b8
jne 0x6aa7
movq $-0x1, %rdi
leaq 0x55da(%rip), %rsi # 0xc075
callq 0x5180
movq %rax, 0x9711(%rip) # 0x101b8
callq 0xafb0
testb $0x1, %al
jne 0x6acd
movq 0x9701... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
write | ssize_t write( int fd, const void *buf, size_t nbyte ) //special write which would return only on successfully writing entire data
{
HOOK_SYS_FUNC( write );
if( !co_is_enable_sys_hook() )
{
return g_sys_write_func( fd,buf,nbyte );
}
rpchook_t *lp = get_by_fd( fd );
if( !lp || ( O_NONBLOCK & lp->user_flag ) )... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, 0x9595(%rip) # 0x101c0
jne 0x6c47
movq $-0x1, %rdi
leaq 0x543f(%rip), %rsi # 0xc07a
callq 0x5180
movq %rax, 0x9579(%rip) # 0x101c0
callq 0xafb0
testb $0x1, %al
jne 0x6c6d
movq 0x9569... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
sendto | ssize_t sendto(int socket, const void *message, size_t length,
int flags, const struct sockaddr *dest_addr,
socklen_t dest_len)
{
/*
1.no enable sys call ? sys
2.( !lp || lp is non block ) ? sys
3.try
4.wait
5.try
*/
HOOK_SYS_FUNC( sendto );
if( !co_is_enable_sys_hook... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpq $0x0, 0x9392(%rip) # 0x101c8
jne 0x6e52
movq $-0x1, %rdi
leaq 0x523a(%rip), %rsi # 0xc080
callq 0x5180
movq %rax, 0x9376(%rip... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
recvfrom | ssize_t recvfrom(int socket, void *buffer, size_t length,
int flags, struct sockaddr *address,
socklen_t *address_len)
{
HOOK_SYS_FUNC( recvfrom );
if( !co_is_enable_sys_hook() )
{
return g_sys_recvfrom_func( socket,buffer,length,flags,address,address_len );
}
rpchook_t *lp... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, 0x917a(%rip) # 0x101d0
jne 0x7072
movq $-0x1, %rdi
leaq 0x5021(%rip), %rsi # 0xc087
callq 0x5180
movq %rax, 0x915e(%rip)... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
send | ssize_t send(int socket, const void *buffer, size_t length, int flags)
{
HOOK_SYS_FUNC( send );
if( !co_is_enable_sys_hook() )
{
return g_sys_send_func( socket,buffer,length,flags );
}
rpchook_t *lp = get_by_fd( socket );
if( !lp || ( O_NONBLOCK & lp->user_flag ) )
{
return g_sys_send_func( socket,buffer,... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, 0x901a(%rip) # 0x101d8
jne 0x71da
movq $-0x1, %rdi
leaq 0x4ec2(%rip), %rsi # 0xc090
callq 0x5180
movq %rax, 0x8ffe(%rip) # 0x101d8
callq 0xafb0
testb $0x1, %al... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
recv | ssize_t recv( int socket, void *buffer, size_t length, int flags )
{
HOOK_SYS_FUNC( recv );
if( !co_is_enable_sys_hook() )
{
return g_sys_recv_func( socket,buffer,length,flags );
}
rpchook_t *lp = get_by_fd( socket );
if( !lp || ( O_NONBLOCK & lp->user_flag ) )
{
return g_sys_recv_func( socket,buffer,len... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, 0x8e22(%rip) # 0x101e0
jne 0x73da
movq $-0x1, %rdi
leaq 0x4cc7(%rip), %rsi # 0xc095
callq 0x5180
movq %rax, 0x8e06(%rip) # 0x101e0
callq 0xafb0
testb $0x1, %al... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
setsockopt | int setsockopt(int fd, int level, int option_name,
const void *option_value, socklen_t option_len)
{
HOOK_SYS_FUNC( setsockopt );
if( !co_is_enable_sys_hook() )
{
return g_sys_setsockopt_func( fd,level,option_name,option_value,option_len );
}
rpchook_t *lp = get_by_fd( fd );
if( lp && SOL_... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
cmpq $0x0, 0x8c8f(%rip) # 0x101f0
jne 0x757d
movq $-0x1, %rdi
leaq 0x4b29(%rip), %rsi # 0xc09a
callq 0x5180
movq %rax, 0x8c73(%rip) # 0x101f0
callq ... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
co_set_env_list(char const**, unsigned long) | void co_set_env_list( const char *name[],size_t cnt)
{
if( g_co_sysenv.data )
{
return ;
}
g_co_sysenv.data = (stCoSysEnv_t*)calloc( 1,sizeof(stCoSysEnv_t) * cnt );
for(size_t i=0;i<cnt;i++)
{
if( name[i] && name[i][0] )
{
g_co_sysenv.data[ g_co_sysenv.cnt++ ].name = strdup( name[i] );
}
}
if( g_co... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x8ba8(%rip) # 0x10230
je 0x768f
jmp 0x77fd
movq -0x10(%rbp), %rsi
shlq $0x4, %rsi
movl $0x1, %edi
callq 0x5100
movq %rax, 0x8b88(%rip) # 0x10230
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), ... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
setenv | int setenv(const char *n, const char *value, int overwrite)
{
HOOK_SYS_FUNC( setenv )
if( co_is_enable_sys_hook() && g_co_sysenv.data )
{
stCoRoutine_t *self = co_self();
if( self )
{
if( !self->pvEnv )
{
self->pvEnv = dup_co_sysenv_arr( &g_co_sysenv );
}
stCoSysEnvArr_t *arr = (stCoSysEnvArr_t... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, 0x89a2(%rip) # 0x10200
jne 0x787a
movq $-0x1, %rdi
leaq 0x483f(%rip), %rsi # 0xc0ad
callq 0x5180
movq %rax, 0x8986(%rip) # 0x10200
callq 0xafb0
movb %al, -0x49(%rbp)
jmp 0x7884
movb... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
getenv | char *getenv( const char *n )
{
HOOK_SYS_FUNC( getenv )
if( co_is_enable_sys_hook() && g_co_sysenv.data )
{
stCoRoutine_t *self = co_self();
stCoSysEnv_t name = { (char*)n,0 };
if( !self->pvEnv )
{
self->pvEnv = dup_co_sysenv_arr( &g_co_sysenv );
}
stCoSysEnvArr_t *arr = (stCoSysEnvArr_t*)(self->pvE... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x863c(%rip) # 0x10210
jne 0x7bf0
movq $-0x1, %rdi
leaq 0x44d0(%rip), %rsi # 0xc0b4
callq 0x5180
movq %rax, 0x8620(%rip) # 0x10210
callq 0xafb0
movb %al, -0x39(%rbp)
jmp 0x7bfa
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x7c06
j... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
gethostbyname | struct hostent *gethostbyname(const char *name)
{
HOOK_SYS_FUNC( gethostbyname );
#if defined( __APPLE__ ) || defined( __FreeBSD__ )
return g_sys_gethostbyname_func( name );
#else
if (!co_is_enable_sys_hook())
{
return g_sys_gethostbyname_func(name);
}
return co_gethostbyname(name);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x851c(%rip) # 0x10220
jne 0x7d20
movq $-0x1, %rdi
leaq 0x43b3(%rip), %rsi # 0xc0c7
callq 0x5180
movq %rax, 0x8500(%rip) # 0x10220
callq 0xafb0
testb $0x1, %al
jne 0x7d3c
movq 0x84f0(%rip), %rax # 0x10220
movq -0x10(%rbp),... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
co_gethostbyname(char const*) | struct hostent *co_gethostbyname(const char *name)
{
if (!name)
{
return NULL;
}
if (__co_hostbuf_wrap->buffer && __co_hostbuf_wrap->iBufferSize > 1024)
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->buffer = NULL;
}
if (!__co_hostbuf_wrap->buffer)
{
__co_hostbuf_wrap->buffer = (char*)malloc(102... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7d80
movq $0x0, -0x8(%rbp)
jmp 0x7f5c
leaq 0x84ba(%rip), %rdi # 0x10241
callq 0x8340
cmpq $0x0, 0x20(%rax)
je 0x7dd2
leaq 0x84a7(%rip), %rdi # 0x10241
callq 0x8340
cmpq $0x400, 0x28(%rax) # imm = 0x400
jbe 0x7... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
routine_make_key_hostbuf_wrap() | struct hostent *co_gethostbyname(const char *name)
{
if (!name)
{
return NULL;
}
if (__co_hostbuf_wrap->buffer && __co_hostbuf_wrap->iBufferSize > 1024)
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->buffer = NULL;
}
if (!__co_hostbuf_wrap->buffer)
{
__co_hostbuf_wrap->buffer = (char*)malloc(102... | pushq %rbp
movq %rsp, %rbp
leaq 0x7a9409(%rip), %rdi # 0x7b1464
xorl %eax, %eax
movl %eax, %esi
callq 0x5270
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /abhinavabcd[P]libco/co_hook_sys_call.cpp |
clsRoutineData_routine_hostbuf_wrap<hostbuf_wrap>::operator->() | struct hostent *co_gethostbyname(const char *name)
{
if (!name)
{
return NULL;
}
if (__co_hostbuf_wrap->buffer && __co_hostbuf_wrap->iBufferSize > 1024)
{
free(__co_hostbuf_wrap->buffer);
__co_hostbuf_wrap->buffer = NULL;
}
if (!__co_hostbuf_wrap->buffer)
{
__co_hostbuf_wrap->buffer = (char*)malloc(102... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x7a9109(%rip) # 0x7b145c
jne 0x8372
leaq 0x7a9104(%rip), %rdi # 0x7b1460
leaq -0x313(%rip), %rsi # 0x8050
callq 0x5170
movl $0x1, 0x7a90ea(%rip) # 0x7b145c
movl 0x7a90ec(%rip), %edi # 0x7b1464
callq 0xaec0
movq %rax, -0x10(%r... | /abhinavabcd[P]libco/co_hook_sys_call.cpp |
co_alloc_stackmem(unsigned int) | stStackMem_t* co_alloc_stackmem(unsigned int stack_size)
{
stStackMem_t* stack_mem = (stStackMem_t*)malloc(sizeof(stStackMem_t));
stack_mem->occupy_co= NULL;
stack_mem->stack_size = stack_size;
stack_mem->stack_buffer = (char*)malloc(stack_size);
stack_mem->stack_bp = stack_mem->stack_buffer + stack_size;
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x20, %edi
callq 0x5210
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x4(%rbp), %eax
movl %eax, %edi
callq 0x5210
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq... | /abhinavabcd[P]libco/co_routine.cpp |
co_alloc_sharestack(int, int) | stShareStack_t* co_alloc_sharestack(int count, int stack_size)
{
stShareStack_t* share_stack = (stShareStack_t*)malloc(sizeof(stShareStack_t));
share_stack->alloc_idx = 0;
share_stack->stack_size = stack_size;
//alloc stack array
share_stack->count = count;
stStackMem_t** stack_array = (stStackMem_t**)calloc(cou... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x18, %edi
callq 0x5210
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movslq... | /abhinavabcd[P]libco/co_routine.cpp |
AllocTimeout(int) | stTimeout_t *AllocTimeout( int iSize )
{
stTimeout_t *lp = (stTimeout_t*)calloc( 1,sizeof(stTimeout_t) );
lp->iItemSize = iSize;
lp->pItems = (stTimeoutItemLink_t*)calloc( 1,sizeof(stTimeoutItemLink_t) * lp->iItemSize );
lp->ullStart = GetTickMS();
lp->llStartIdx = 0;
return lp;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x5100
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rsi
shlq $0x4, %rsi
movl $0x1, %edi
callq 0x5100
movq %rax, %rcx
movq -0x10(%... | /abhinavabcd[P]libco/co_routine.cpp |
AddTimeout(stTimeout_t*, stTimeoutItem_t*, unsigned long long) | int AddTimeout( stTimeout_t *apTimeout,stTimeoutItem_t *apItem ,unsigned long long allNow )
{
if( apTimeout->ullStart == 0 )
{
apTimeout->ullStart = allNow;
apTimeout->llStartIdx = 0;
}
if( allNow < apTimeout->ullStart )
{
co_log_err("CO_ERR: AddTimeout line %d allNow %llu apTimeout->ullStart %llu",
__L... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x9a47
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp... | /abhinavabcd[P]libco/co_routine.cpp |
co_create_env(stCoRoutineEnv_t*, stCoRoutineAttr_t const*, void* (*)(void*), void*) | struct stCoRoutine_t *co_create_env( stCoRoutineEnv_t * env, const stCoRoutineAttr_t* attr,
pfn_co_routine_t pfn,void *arg )
{
stCoRoutineAttr_t at;
if( attr )
{
memcpy( &at,attr,sizeof(at) );
}
if( at.stack_size <= 0 )
{
at.stack_size = 128 * 1024;
}
else if( at.stack_size > 1024 * 1024 * 8 )
{
at.st... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0xb310
cmpq $0x0, -0x10(%rbp)
je 0x9b89
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x2c(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x... | /abhinavabcd[P]libco/co_routine.cpp |
co_init_curr_thread_env() | void co_init_curr_thread_env()
{
gCoEnvPerThread = (stCoRoutineEnv_t*)calloc( 1, sizeof(stCoRoutineEnv_t) );
stCoRoutineEnv_t *env = gCoEnvPerThread;
env->iCallStackSize = 0;
struct stCoRoutine_t *self = co_create_env( env, NULL, NULL,NULL );
self->cIsMain = 1;
env->pending_co = NULL;
env->occupy_co = NULL;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %edi
movl $0x420, %esi # imm = 0x420
callq 0x5100
movq %rax, %rcx
movq %fs:0x0, %rax
leaq -0x10(%rax), %rax
movq %rcx, (%rax)
movq %fs:0x0, %rax
leaq -0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x400(%rax)
m... | /abhinavabcd[P]libco/co_routine.cpp |
co_resume(stCoRoutine_t*) | void co_resume( stCoRoutine_t *co )
{
stCoRoutineEnv_t *env = co->env;
stCoRoutine_t *lpCurrRoutine = env->pCallStack[ env->iCallStackSize - 1 ];
if( !co->cStart )
{
coctx_make( &co->ctx,(coctx_pfn_t)CoRoutineFunc,co,0 );
co->cStart = 1;
}
env->pCallStack[ env->iCallStackSize++ ] = co;
co_swap( lpCurrRoutine... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x400(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x98(%r... | /abhinavabcd[P]libco/co_routine.cpp |
co_swap(stCoRoutine_t*, stCoRoutine_t*) | void co_swap(stCoRoutine_t* curr, stCoRoutine_t* pending_co)
{
stCoRoutineEnv_t* env = co_get_curr_thread_env();
//get curr stack sp
char c;
curr->stack_sp= &c;
if (!pending_co->cIsShareStack)
{
env->pending_co = NULL;
env->occupy_co = NULL;
}
else
{
env->pending_co = pending_co;
//get last occupy ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x9d90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
leaq -0x19(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x9c(%rax)
jne 0xa0a5
movq -0x18(%rbp), %rax
movq $0x0, 0x410(%rax)
movq -0x18(%rbp), %rax
mov... | /abhinavabcd[P]libco/co_routine.cpp |
co_reset(stCoRoutine_t*) | void co_reset(stCoRoutine_t * co)
{
if(!co->cStart || co->cIsMain)
return;
co->cStart = 0;
co->cEnd = 0;
// 如果当前协程有共享栈被切出的buff，要进行释放
if(co->save_buffer)
{
free(co->save_buffer);
co->save_buffer = NULL;
co->save_size = 0;
}
// 如果共享栈被当前协程占用，要释放占用标志，否则被切换，... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x98(%rax)
je 0xa1d6
movq -0x8(%rbp), %rax
cmpb $0x0, 0x9a(%rax)
je 0xa1d8
jmp 0xa24f
movq -0x8(%rbp), %rax
movb $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x99(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je ... | /abhinavabcd[P]libco/co_routine.cpp |
save_stack_buffer(stCoRoutine_t*) | void save_stack_buffer(stCoRoutine_t* occupy_co)
{
///copy out
stStackMem_t* stack_mem = occupy_co->stack_mem;
int len = stack_mem->stack_bp - occupy_co->stack_sp;
if (occupy_co->save_buffer)
{
free(occupy_co->save_buffer), occupy_co->save_buffer = NULL;
}
occupy_co->save_buffer = (char*)malloc(len); //mallo... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb0(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc0(%rax)
je 0xa371
movq ... | /abhinavabcd[P]libco/co_routine.cpp |
AllocEpoll() | stCoEpoll_t *AllocEpoll()
{
stCoEpoll_t *ctx = (stCoEpoll_t*)calloc( 1,sizeof(stCoEpoll_t) );
ctx->iEpollFd = co_epoll_create( stCoEpoll_t::_EPOLL_SIZE );
ctx->pTimeout = AllocTimeout( 60 * 1000 );
ctx->pstActiveList = (stTimeoutItemLink_t*)calloc( 1,sizeof(stTimeoutItemLink_t) );
ctx->pstTimeoutList = (stTimeo... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x28, %esi
callq 0x5100
movq %rax, -0x8(%rbp)
movl $0x2800, %edi # imm = 0x2800
callq 0xbbe0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl $0xea60, %edi # imm = 0xEA60
callq 0x9910
movq %rax, %rcx
movq -0x8(%rbp), %rax
... | /abhinavabcd[P]libco/co_routine.cpp |
OnPollPreparePfn(stTimeoutItem_t*, epoll_event&, stTimeoutItemLink_t*) | void OnPollPreparePfn( stTimeoutItem_t * ap,struct epoll_event &e,stTimeoutItemLink_t *active )
{
stPollItem_t *lp = (stPollItem_t *)ap;
lp->pSelf->revents = EpollEvent2Poll( e.events );
stPoll_t *pPoll = lp->pPoll;
pPoll->iRaiseCnt++;
if( !pPoll->iAllEventDetach )
{
pPoll->iAllEventDetach = 1;
RemoveFrom... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xa510
movw %ax, %cx
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movw %cx, 0x6(%rax)
movq -0x20(%rbp), %rax
movq 0x... | /abhinavabcd[P]libco/co_routine.cpp |
EpollEvent2Poll(unsigned int) | static short EpollEvent2Poll( uint32_t events )
{
short e = 0;
if( events & EPOLLIN ) e |= POLLIN;
if( events & EPOLLOUT ) e |= POLLOUT;
if( events & EPOLLHUP ) e |= POLLHUP;
if( events & EPOLLERR ) e |= POLLERR;
if( events & EPOLLRDNORM ) e |= POLLRDNORM;
if( events & EPOLLWRNORM ) e |= POLLWRNORM;
return e;... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movw $0x0, -0x6(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa533
movswl -0x6(%rbp), %eax
orl $0x1, %eax
movw %ax, -0x6(%rbp)
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa549
movswl -0x6(%rbp), %eax
orl $0x4, %eax
movw %ax, -0x6(%rbp)
m... | /abhinavabcd[P]libco/co_routine.cpp |
co_eventloop(stCoEpoll_t*, int (*)(void*), void*) | void co_eventloop( stCoEpoll_t *ctx,pfn_co_eventloop_t pfn,void *arg )
{
if( !ctx->result )
{
ctx->result = co_epoll_res_alloc( stCoEpoll_t::_EPOLL_SIZE );
}
co_epoll_res *result = ctx->result;
for(;;)
{
int ret = co_epoll_wait( ctx->iEpollFd,result,stCoEpoll_t::_EPOLL_SIZE, 1 );
stTimeoutItemLink_t *ac... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xa5e4
movl $0x2800, %edi # imm = 0x2800
callq 0xbc00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax... | /abhinavabcd[P]libco/co_routine.cpp |
FreeEpoll(stCoEpoll_t*) | void FreeEpoll( stCoEpoll_t *ctx )
{
if( ctx )
{
free( ctx->pstActiveList );
free( ctx->pstTimeoutList );
FreeTimeout( ctx->pTimeout );
co_epoll_res_free( ctx->result );
}
free( ctx );
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa837
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x51d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x51d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x99e0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x... | /abhinavabcd[P]libco/co_routine.cpp |
PollEvent2Epoll(short) | static uint32_t PollEvent2Epoll( short events )
{
uint32_t e = 0;
if( events & POLLIN ) e |= EPOLLIN;
if( events & POLLOUT ) e |= EPOLLOUT;
if( events & POLLHUP ) e |= EPOLLHUP;
if( events & POLLERR ) e |= EPOLLERR;
if( events & POLLRDNORM ) e |= EPOLLRDNORM;
if( events & POLLWRNORM ) e |= EPOLLWRNORM;
retu... | pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
movswl -0x2(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xadd7
movl -0x8(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x8(%rbp)
movswl -0x2(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xadec
movl -0x8(%rbp), %eax
orl $0x4, %eax
movl %ea... | /abhinavabcd[P]libco/co_routine.cpp |
co_cond_signal(stCoCond_t*) | int co_cond_signal( stCoCond_t *si )
{
stCoCondItem_t * sp = co_cond_pop( si );
if( !sp )
{
return 0;
}
RemoveFromLink<stTimeoutItem_t,stTimeoutItemLink_t>( &sp->timeout );
AddTail( co_get_curr_thread_env()->pEpoll->pstActiveList,&sp->timeout );
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb019
movl $0x0, -0x4(%rbp)
jmp 0xb04a
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0xb330
callq 0x9d90
movq 0x408(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp)... | /abhinavabcd[P]libco/co_routine.cpp |
co_cond_timedwait(stCoCond_t*, int) | int co_cond_timedwait( stCoCond_t *link,int ms )
{
stCoCondItem_t* psi = (stCoCondItem_t*)calloc(1, sizeof(stCoCondItem_t));
psi->timeout.pArg = GetCurrThreadCo();
psi->timeout.pfnProcess = OnSignalProcessEvent;
if( ms > 0 )
{
unsigned long long now = GetTickMS();
psi->timeout.ullExpireTime = now + ms;
int... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x5100
movq %rax, -0x20(%rbp)
callq 0xa880
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rax
leaq 0xa3(%rip), %rcx # 0xb1e0
movq %rcx, 0x40(%rax)
cmpl... | /abhinavabcd[P]libco/co_routine.cpp |
void AddTail<stTimeoutItem_t, stTimeoutItemLink_t>(stTimeoutItemLink_t*, stTimeoutItem_t*) | void inline AddTail(TLink*apLink,TNode *ap)
{
if( ap->pLink )
{
return ;
}
if(apLink->tail)
{
apLink->tail->pNext = (TNode*)ap;
ap->pNext = NULL;
ap->pPrev = apLink->tail;
apLink->tail = ap;
}
else
{
apLink->head = apLink->tail = ap;
ap->pNext = ap->pPrev = NULL;
}
ap->pLink = apLink;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb289
jmp 0xb303
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb2cd
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax... | /abhinavabcd[P]libco/co_routine.cpp |
void PopHead<stTimeoutItem_t, stTimeoutItemLink_t>(stTimeoutItemLink_t*) | void inline PopHead( TLink*apLink )
{
if( !apLink->head )
{
return ;
}
TNode *lp = apLink->head;
if( apLink->head == apLink->tail )
{
apLink->head = apLink->tail = NULL;
}
else
{
apLink->head = apLink->head->pNext;
}
lp->pPrev = lp->pNext = NULL;
lp->pLink = NULL;
if( apLink->head )
{
apLink->h... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xb6f7
jmp 0xb779
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xb72c
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8... | /abhinavabcd[P]libco/co_routine.cpp |
void RemoveFromLink<stCoCondItem_t, stCoCond_t>(stCoCondItem_t*) | void RemoveFromLink(T *ap)
{
TLink *lst = ap->pLink;
if(!lst) return ;
assert( lst->head && lst->tail );
if( ap == lst->head )
{
lst->head = ap->pNext;
if(lst->head)
{
lst->head->pPrev = NULL;
}
}
else
{
if(ap->pPrev)
{
ap->pPrev->pNext = ap->pNext;
}
}
if( ap == lst->tail )
{
lst->ta... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb844
jmp 0xb950
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0xb862
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al... | /abhinavabcd[P]libco/co_routine.cpp |
coctx_make(coctx_t*, void* (*)(void*, void*), void const*, void const*) | int coctx_make(coctx_t* ctx, coctx_pfn_t pfn, const void* s, const void* s1) {
char* sp = ctx->ss_sp + ctx->ss_size - sizeof(void*);
sp = (char*)((unsigned long)sp & -16LL);
memset(ctx->regs, 0, sizeof(ctx->regs));
void** ret_addr = (void**)(sp);
*ret_addr = (void*)pfn;
ctx->regs[kRSP] = sp;
ctx->regs[... | 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 -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x70(%rcx), %rax
addq $-0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $-0x10, %rax
movq %rax, -0x28... | /abhinavabcd[P]libco/coctx.cpp |
Eigen::internal::gemm_pack_rhs<double, long, 4, 0, false, false>::operator()(double*, double const*, long, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, nr, ColMajor, Conjugate, PanelMode>
::operator()(Scalar* blockB, const Scalar* rhs, Index rhsStride, Index depth, Index cols, Index stride, Index offset)
{
EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS COLMAJOR");
EIGEN_UNUSED_VARIABLE(stride)
EIGEN_UNUSED_VARIABL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x58(%rsp), %rax
orq 0x50(%rsp), %rax
jne 0x10209
movq %r8, %rdi
leaq 0x3(%r9), %rax
testq %r9, %r9
cmovnsq %r9, %rax
movq %rax, (%rsp)
andq $-0x4, %rax
cmpq $0x4, %r9
movq %rsi, 0x8(%rsp)
jl 0x101a9
addq $0x18, %rsi
movq %rsi, 0x10... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Eigen::PermutationMatrix<-1, -1, int>& Eigen::PermutationBase<Eigen::PermutationMatrix<-1, -1, int>>::operator=<Eigen::Transpositions<-1, -1, int>>(Eigen::TranspositionsBase<Eigen::Transpositions<-1, -1, int>> const&) | Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
{
setIdentity(tr.size());
for(Index k=size()-1; k>=0; --k)
applyTranspositionOnTheRight(k,tr.coeff(k));
return derived();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x1027a
movq 0x8(%rbx), %r15
testl %r15d, %r15d
jle 0x10270
andl $0x7fffffff, %r15d # imm = 0x7FFFFFFF
decq %r15
movq (%r14), %rax
movl (%rax,%r15,4), %edx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x1032c
leaq -0x1(%r15), %ra... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/PermutationMatrix.h |
void Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::ReturnByValue<Eigen::internal::inverse_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>>>, 5>::scaleAndAddTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double const&) const | gemm_blocking_space(DenseIndex /*rows*/, DenseIndex /*cols*/, DenseIndex /*depth*/)
{
this->m_mc = ActualRows;
this->m_nc = ActualCols;
this->m_kc = MaxDepth;
this->m_blockA = m_staticA;
this->m_blockB = m_staticB;
this->m_blockW = m_staticW;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq 0x8(%rsi), %rax
movq (%rdi), %r12
cmpq 0x8(%r12), %rax
jne 0x113a6
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
cmpq 0x18(%rdi), %rcx
jne 0x113a6
testq %rcx, %rcx
je 0x11395
testq %rax, %rax
je 0x11395
movq 0x10(%r12), %rdi
testq %rdi... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::gemm_functor<double, long, Eigen::internal::general_matrix_matrix_product<long, double, 0, false, double, 0, false, 0>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::gemm_blocking_space<0, double, double, -... | void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
{
if(cols==-1)
cols = m_rhs.cols();
Gemm::run(rows, cols, m_lhs.cols(),
/*(const Scalar*)*/&m_lhs.coeffRef(row,0), m_lhs.outerStride(),
/*(const Scalar*)*/&m_rhs.coeffR... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rax
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, %r10
movq 0x8(%rdi), %rdx
cmpq $-0x1, %r8
jne 0x113fd
movq 0x10(%rdx), %rbx
movq (%r10), %rdi
movq 0x10(%r10), %r12
movq 0x8(%rdi), %r8
leaq (,%rsi,8), %r11
addq (%rdi), %r11
movq 0x8(%rdx), %r15
movq %r15, %... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/products/GeneralMatrixMatrix.h |
void Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>::scaleAndAddTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double const&) const | gemm_blocking_space(DenseIndex /*rows*/, DenseIndex /*cols*/, DenseIndex /*depth*/)
{
this->m_mc = ActualRows;
this->m_nc = ActualCols;
this->m_kc = MaxDepth;
this->m_blockA = m_staticA;
this->m_blockB = m_staticB;
this->m_blockW = m_staticW;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq 0x8(%rsi), %rax
movq (%rdi), %r12
cmpq 0x8(%r12), %rax
jne 0x11a5c
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
movq 0x8(%rdi), %r13
cmpq 0x10(%r13), %rcx
jne 0x11a5c
testq %rcx, %rcx
je 0x11a4b
testq %rax, %rax
je 0x11a4b
movq 0x10(%... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::ProductBase<Eigen::GeneralProduct<Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 5>, Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>,... | operator const PlainObject& () const
{
m_result.resize(m_lhs.rows(), m_rhs.cols());
derived().evalTo(m_result);
return m_result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x8(%rax), %r8
movq 0x8(%rcx), %rcx
movq %rcx, %rax
orq %r8, %rax
js 0x11b4f
movq %rdi, %rbx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x11adf
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFF... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/ProductBase.h |
void Eigen::GeneralProduct<Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 5>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, 5>::scaleAndAddTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double const&) const | gemm_blocking_space(DenseIndex /*rows*/, DenseIndex /*cols*/, DenseIndex /*depth*/)
{
this->m_mc = ActualRows;
this->m_nc = ActualCols;
this->m_kc = MaxDepth;
this->m_blockA = m_staticA;
this->m_blockB = m_staticB;
this->m_blockW = m_staticW;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq 0x8(%rsi), %rax
movq (%rdi), %r12
cmpq 0x8(%r12), %rax
jne 0x11ce7
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
movq 0x8(%rdi), %rsi
cmpq 0x8(%rsi), %rcx
jne 0x11ce7
testq %rcx, %rcx
je 0x11cd6
testq %rax, %rax
je 0x11cd6
movq 0x10(%r... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::internal::gemm_functor<double, long, Eigen::internal::general_matrix_matrix_product<long, double, 0, false, double, 1, false, 0>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1> const>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::gemm_blocking_sp... | void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
{
if(cols==-1)
cols = m_rhs.cols();
Gemm::run(rows, cols, m_lhs.cols(),
/*(const Scalar*)*/&m_lhs.coeffRef(row,0), m_lhs.outerStride(),
/*(const Scalar*)*/&m_rhs.coeffR... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rax
movq %r8, %r14
movq %rdx, %rbx
movq %rdi, %r10
cmpq $-0x1, %r8
movq (%rdi), %rdx
movq 0x8(%rdi), %rdi
movq (%rdi), %rdi
movq 0x8(%rdi), %r15
cmoveq %r15, %r14
movq 0x8(%rdx), %r8
leaq (,%rsi,8), %r11
addq (%rdx), %r11
movq 0x10(%rdx), %rdx
leaq (,%rc... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/products/GeneralMatrixMatrix.h |
Eigen::Matrix<double, -1, -1, 0, -1, -1>& Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::lazyAssign<Eigen::CwiseBinaryOp<Eigen::internal::scalar_difference_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::GeneralProduct<Eigen::GeneralProduct<Eigen::Matrix<double, -1, -1, 0, -1, -1>,... | EIGEN_STRONG_INLINE Derived& lazyAssign(const DenseBase<OtherDerived>& other)
{
_resize_to_match(other);
return Base::lazyAssign(other.derived());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x8(%rax), %r8
movq 0x10(%rax), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x1232a
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x1241b
mov... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/PlainObjectBase.h |
Eigen::ProductBase<Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::ReturnByValue<Eigen::internal::inverse_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>>>, 4>, Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::ReturnByValue<Eigen::internal::inverse_impl<Eigen::Matrix... | ProductBase(const Lhs& a_lhs, const Rhs& a_rhs)
: m_lhs(a_lhs), m_rhs(a_rhs)
{
eigen_assert(a_lhs.cols() == a_rhs.rows()
&& "invalid matrix product"
&& "if you wanted a coeff-wise or a dot product use the respective explicit functions");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movq (%rdx), %rax
movq 0x8(%rax), %r8
movq 0x10(%rax), %rcx
movq %rcx, %rax
orq %r8, %rax
js 0x124f1
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi),... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/ProductBase.h |
Eigen::GeneralProduct<Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::ReturnByValue<Eigen::internal::inverse_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>>>, 4>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 3>::GeneralProduct(Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double,... | GeneralProduct(const Lhs& lhs, const Rhs& rhs)
{
Base::coeffRef(0,0) = (lhs.transpose().cwiseProduct(rhs)).sum();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x125de
movq %rax, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq 0x8(%rax), %rax
cmpq 0x8(%r14), %rax
jne 0x125be
testq %rax, %rax
je 0x125af
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x131e8
jmp 0x125b2
xorps %xmm0, %xmm0
movsd... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/GeneralProduct.h |
void Eigen::PlainObjectBase<Eigen::Matrix<double, 1, -1, 1, 1, -1>>::resizeLike<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 1, -1, 1, 1, -1>>>(Eigen::EigenBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 1, -1, 1, 1, -1>>> const&) | EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
{
const OtherDerived& other = _other.derived();
internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(Index(other.rows()), Index(other.cols()));
const Index othersize = Index(other.rows())*Index(other.cols());
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0x127fd
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %r14
testq %rax, %rax
jle 0x1282b
testq %r14, %r14
js 0x1286a
cmpq %r14, 0x8(%rbx)
je 0x1285e
movq (%rbx), %rdi
callq 0x3280
testq %r14, %r... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/PlainObjectBase.h |
Eigen::internal::general_matrix_vector_product<long, double, 1, false, double, false, 0>::run(long, long, double const*, long, double const*, long, double*, long, double) | EIGEN_DONT_INLINE void general_matrix_vector_product<Index,LhsScalar,RowMajor,ConjugateLhs,RhsScalar,ConjugateRhs,Version>::run(
Index rows, Index cols,
const LhsScalar* lhs, Index lhsStride,
const RhsScalar* rhs, Index rhsIncr,
ResScalar* res, Index resIncr,
ResScalar alpha)
{
EIGEN_UNUSED_VARIABLE(rhsIncr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x68(%rsp)
movl %r8d, %r12d
shrl $0x3, %r12d
andl $0x1, %r12d
cmpq %rsi, %r12
cmovgeq %rsi, %r12
testb $0x7, %r8b
cmovneq %rsi, %r12
movq %rsi, %r13
subq %r12, %r13
andq $-0x2, %r13
movl %ecx, %r10d
andl $0x1, %r10d
movl %r8d... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/products/GeneralMatrixVector.h |
Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::Transpose<Eigen::GeneralProduct<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::ReturnByValue<Eigen::internal::inverse_impl<Eigen::Matrix<double, -1, -1, 0... | static Scalar run(const Derived& mat, const Func& func)
{
const Index size = mat.size();
eigen_assert(size && "you are using an empty matrix");
const Index packetSize = packet_traits<Scalar>::size;
const Index alignedStart = internal::first_aligned(mat);
enum {
alignment = bool(Derived::Flag... | pushq %rax
movq 0x8(%rdi), %rcx
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0x132cb
leaq 0x3(%rax), %r8
testq %rax, %rax
cmovnsq %rax, %r8
leaq 0x1(%rax), %rsi
movq (%rdi), %rdx
movq (%rdx), %rdx
movq (%rcx), %rcx
cmpq $0x3, %rsi
jae 0x13225
movsd (%rdx), %xmm0
mulsd (%rcx), %xmm0
jmp 0x132c9
movq %rax, %rsi
shrq $0x3f, %... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/Redux.h |
check_arguments(int, char**) | void check_arguments(int argc, char* argv[]) {
string usage_instructions = "Usage instructions: ";
usage_instructions += argv[0];
usage_instructions += " path/to/input.txt output.txt";
bool has_valid_args = false;
// make sure the user has provided input and output files
if (argc == 1) {
cerr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %ebx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe180(%rip), %rsi # 0x2148d
leaq 0xe18d(%rip), %rdx # 0x214a1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x14b9e
movq (%r14), %rsi
movq %r15, %rdi
callq 0x33c0
leaq 0... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/main.cpp |
main | int main(int argc, char* argv[]) {
check_arguments(argc, argv);
string in_file_name_ = argv[1];
ifstream in_file_(in_file_name_.c_str(), ifstream::in);
string out_file_name_ = argv[2];
ofstream out_file_(out_file_name_.c_str(), ofstream::out);
check_files(in_file_, in_file_name_, out_file_, ou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x738, %rsp # imm = 0x738
movq %rsi, %rbx
callq 0x132ec
movq 0x8(%rbx), %rsi
leaq 0x190(%rsp), %r14
leaq 0x530(%rsp), %rdx
movq %r14, %rdi
callq 0x30d0
movq (%r14), %rsi
leaq 0x530(%rsp), %rdi
movl $0x8, %edx
callq 0x3390
movq 0x10(%rbx)... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/main.cpp |
std::ostream& Eigen::operator<<<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(std::ostream&, Eigen::DenseBase<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const&) | std::ostream & operator <<
(std::ostream & s,
const DenseBase<Derived> & m)
{
return internal::print_matrix(s, m.eval(), EIGEN_DEFAULT_IO_FORMAT);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2b50(%rip), %rsi # 0x17344
leaq 0x2b4a(%rip), %rdx # 0x17345
leaq 0x40(%rsp), %rdi
callq 0x14b9e
leaq 0x30(%rsp), %ra... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/IO.h |
std::ostream& Eigen::internal::print_matrix<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(std::ostream&, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, Eigen::IOFormat const&) | std::ostream & print_matrix(std::ostream & s, const Derived& _m, const IOFormat& fmt)
{
if(_m.size() == 0)
{
s << fmt.matPrefix << fmt.matSuffix;
return s;
}
typename Derived::Nested m = _m;
typedef typename Derived::Scalar Scalar;
typedef typename Derived::Index Index;
Index width = 0;
std... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x1580d
movq %rsi, %r15
movslq 0xe0(%r14), %rcx
cmpq $-0x2, %rcx
je 0x15831
movb $0x1, %dl
cmpl $-0x1, %ecx
je 0x15803
testl %ecx, %ecx
jn... | /chrisgundling[P]Udacity-T2P2-UnscentedKalmanFilter/src/Eigen/src/Core/IO.h |
main | int main(int argc, char **argv)
{
(void)argc;
(void)argv;
std::string key;
std::string in_file_name;
std::string out_file_name;
int c = 0;
while ((c = getopt(argc, argv, "i:o:k:vh")) != -1)
{
switch (c)
{
case 'i': in_file_name = optarg;
break;
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2270
leaq -0x50(%rbp), %rdi
callq 0x2270
leaq -0x70(%rbp), %rdi
callq 0x2270
movl $0x0, -0x74(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x3a80(%rip), %rdx # 0x... | /Elesarf[P]salsa20/src/main.cpp |
salsa20::generate_keystream() | salsa20::block_array salsa20::generate_keystream()
{
auto x = m_array;
for (size_t i = 20; i > 0; --i)
{
x[4 ] ^= rotate(static_cast<uint32_t>(x[0 ] + x[12]), 7);
x[8 ] ^= rotate(static_cast<uint32_t>(x[4 ] + x[0 ]), 9);
x[12] ^= rotate(static_cast<uint32_t>(x[8 ] + x[4 ]), 13);
... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x40, %edx
callq 0x2140
movq $0x14, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jbe 0x3dc1
leaq -0x48(%rbp), %rdi
xor... | /Elesarf[P]salsa20/src/salsa20.cpp |
main | int main( int argc, char** argv )
{
//initialize random seed
initializeRandomSeed();
//set experiment parameters
double noise = 0.5;
double outlierFraction = 0.1;
size_t pointsPerCam = 25;
int numberCameras = 4;
//create a random viewpoint pose
translation_t position = generateRandomTranslation(2.0)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x340, %rsp # imm = 0x340
callq 0xf71a8
leaq 0x108(%rsp), %rdi
vmovsd 0xcd16f(%rip), %xmm0 # 0xfd008
callq 0xf7515
leaq 0x1f0(%rsp), %rdi
vmovsd 0xcd162(%rip), %xmm0 # 0xfd010
callq 0xf799f
xorl %e... | /simogasp[P]opengv/test/test_multi_noncentral_absolute_pose_sac.cpp |
opengv::sac_problems::absolute_pose::MultiNoncentralAbsolutePoseSacProblem::MultiNoncentralAbsolutePoseSacProblem(opengv::absolute_pose::AbsoluteMultiAdapterBase&, bool) | MultiNoncentralAbsolutePoseSacProblem(adapter_t & adapter, bool asCentral = false) :
sac::MultiSampleConsensusProblem<model_t> (),
_adapter(adapter),
_asCentral(asCentral)
{
std::vector<int> numberCorrespondences;
for(size_t i = 0; i < adapter.getNumberFrames(); i++)
numberCorresponden... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %esi
callq 0x31008
leaq 0xde507(%rip), %rax # 0x10ec58
addq $0x10, %rax
movq %rax, (%rbx)
movq %r14, 0x13e0(%rbx)
movb %bpl, 0x13e8(%rbx)
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10... | /simogasp[P]opengv/include/opengv/sac_problems/absolute_pose/MultiNoncentralAbsolutePoseSacProblem.hpp |
opengv::sac::MultiSampleConsensusProblem<Eigen::Matrix<double, 3, 4, 0, 3, 4>>::MultiSampleConsensusProblem(bool) | opengv::sac::MultiSampleConsensusProblem<M>::MultiSampleConsensusProblem(
bool randomSeed) :
max_sample_checks_(10)
{
rng_dist_.reset(new std::uniform_int_distribution<>( 0, std::numeric_limits<int>::max () ));
// Create a random number generator object
if (randomSeed)
rng_alg_.seed(static_cast<unsign... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xdd7fe(%rip), %rax # 0x10e820
addq $0x10, %rax
movq %rax, (%rdi)
movl $0xa, 0x8(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rdi), %r14
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x... | /simogasp[P]opengv/include/opengv/sac/implementation/MultiSampleConsensusProblem.hpp |
opengv::absolute_pose::modules::gpnp5::groebnerRow18_10000_f(Eigen::Matrix<double, 44, 80, 0, 44, 80>&, int) | void
opengv::absolute_pose::modules::gpnp5::groebnerRow18_10000_f( Eigen::Matrix<double,44,80> & groebnerMatrix, int targetRow )
{
double factor = groebnerMatrix(targetRow,20) / groebnerMatrix(18,53);
groebnerMatrix(targetRow,20) = 0.0;
groebnerMatrix(targetRow,21) -= factor * groebnerMatrix(18,54);
groebnerMat... | movslq %esi, %rax
vmovsd 0x1b80(%rdi,%rax,8), %xmm0
vxorpd 0x5f7a1(%rip){1to2}, %xmm0, %xmm0 # 0xfda30
vdivsd 0x4970(%rdi), %xmm0, %xmm0
movq $0x0, 0x1b80(%rdi,%rax,8)
vmovsd 0x4ad0(%rdi), %xmm1
vfmadd213sd 0x1ce0(%rdi,%rax,8), %xmm0, %xmm1 # xmm1 = (xmm0 * xmm1) + mem
vmovsd %xmm1, 0x1ce0(%rdi,%rax,8)
vmovsd 0x4c30(%r... | /simogasp[P]opengv/src/absolute_pose/modules/gpnp5/reductors.cpp |
opengv::absolute_pose::modules::gpnp5::groebnerRow14_10000_f(Eigen::Matrix<double, 44, 80, 0, 44, 80>&, int) | void
opengv::absolute_pose::modules::gpnp5::groebnerRow14_10000_f( Eigen::Matrix<double,44,80> & groebnerMatrix, int targetRow )
{
double factor = groebnerMatrix(targetRow,10) / groebnerMatrix(14,43);
groebnerMatrix(targetRow,10) = 0.0;
groebnerMatrix(targetRow,17) -= factor * groebnerMatrix(14,50);
groebnerMat... | movslq %esi, %rax
vmovsd 0xdc0(%rdi,%rax,8), %xmm0
vxorpd 0x5f313(%rip){1to2}, %xmm0, %xmm0 # 0xfda30
vdivsd 0x3b90(%rdi), %xmm0, %xmm0
movq $0x0, 0xdc0(%rdi,%rax,8)
vmovsd 0x4530(%rdi), %xmm1
vfmadd213sd 0x1760(%rdi,%rax,8), %xmm0, %xmm1 # xmm1 = (xmm0 * xmm1) + mem
vmovsd %xmm1, 0x1760(%rdi,%rax,8)
vmovsd 0x4690(%rdi... | /simogasp[P]opengv/src/absolute_pose/modules/gpnp5/reductors.cpp |
opengv::absolute_pose::modules::gpnp5::groebnerRow20_00000_f(Eigen::Matrix<double, 44, 80, 0, 44, 80>&, int) | void
opengv::absolute_pose::modules::gpnp5::groebnerRow20_00000_f( Eigen::Matrix<double,44,80> & groebnerMatrix, int targetRow )
{
double factor = groebnerMatrix(targetRow,22) / groebnerMatrix(20,22);
groebnerMatrix(targetRow,22) = 0.0;
groebnerMatrix(targetRow,23) -= factor * groebnerMatrix(20,23);
groebnerMat... | movslq %esi, %rax
vmovsd 0x1e40(%rdi,%rax,8), %xmm0
vxorpd 0x5e81c(%rip){1to2}, %xmm0, %xmm0 # 0xfda30
vdivsd 0x1ee0(%rdi), %xmm0, %xmm0
movq $0x0, 0x1e40(%rdi,%rax,8)
vmovsd 0x2040(%rdi), %xmm1
vfmadd213sd 0x1fa0(%rdi,%rax,8), %xmm0, %xmm1 # xmm1 = (xmm0 * xmm1) + mem
vmovsd %xmm1, 0x1fa0(%rdi,%rax,8)
vmovsd 0x21a0(%r... | /simogasp[P]opengv/src/absolute_pose/modules/gpnp5/reductors.cpp |
opengv::absolute_pose::modules::gpnp5::groebnerRow21_00000_f(Eigen::Matrix<double, 44, 80, 0, 44, 80>&, int) | void
opengv::absolute_pose::modules::gpnp5::groebnerRow21_00000_f( Eigen::Matrix<double,44,80> & groebnerMatrix, int targetRow )
{
double factor = groebnerMatrix(targetRow,23) / groebnerMatrix(21,23);
groebnerMatrix(targetRow,23) = 0.0;
groebnerMatrix(targetRow,24) -= factor * groebnerMatrix(21,24);
groebnerMat... | movslq %esi, %rax
vmovsd 0x1fa0(%rdi,%rax,8), %xmm0
vxorpd 0x5e2b6(%rip){1to2}, %xmm0, %xmm0 # 0xfda30
vdivsd 0x2048(%rdi), %xmm0, %xmm0
movq $0x0, 0x1fa0(%rdi,%rax,8)
vmovsd 0x21a8(%rdi), %xmm1
vfmadd213sd 0x2100(%rdi,%rax,8), %xmm0, %xmm1 # xmm1 = (xmm0 * xmm1) + mem
vmovsd %xmm1, 0x2100(%rdi,%rax,8)
vmovsd 0x2308(%r... | /simogasp[P]opengv/src/absolute_pose/modules/gpnp5/reductors.cpp |
opengv::absolute_pose::modules::gpnp5::groebnerRow11_10000_f(Eigen::Matrix<double, 44, 80, 0, 44, 80>&, int) | void
opengv::absolute_pose::modules::gpnp5::groebnerRow11_10000_f( Eigen::Matrix<double,44,80> & groebnerMatrix, int targetRow )
{
double factor = groebnerMatrix(targetRow,7) / groebnerMatrix(11,40);
groebnerMatrix(targetRow,7) = 0.0;
groebnerMatrix(targetRow,8) -= factor * groebnerMatrix(11,41);
groebnerMatrix... | movslq %esi, %rax
vmovsd 0x9a0(%rdi,%rax,8), %xmm0
vxorpd 0x5cdcb(%rip){1to2}, %xmm0, %xmm0 # 0xfda30
vdivsd 0x3758(%rdi), %xmm0, %xmm0
movq $0x0, 0x9a0(%rdi,%rax,8)
vmovsd 0x38b8(%rdi), %xmm1
vfmadd213sd 0xb00(%rdi,%rax,8), %xmm0, %xmm1 # xmm1 = (xmm0 * xmm1) + mem
vmovsd %xmm1, 0xb00(%rdi,%rax,8)
vmovsd 0x3a18(%rdi),... | /simogasp[P]opengv/src/absolute_pose/modules/gpnp5/reductors.cpp |
opengv::absolute_pose::modules::gpnp5::sPolynomial8(Eigen::Matrix<double, 44, 80, 0, 44, 80>&) | void
opengv::absolute_pose::modules::gpnp5::sPolynomial8( Eigen::Matrix<double,44,80> & groebnerMatrix )
{
groebnerMatrix(8,60) = (groebnerMatrix(2,60)/(groebnerMatrix(2,59))-groebnerMatrix(3,60)/(groebnerMatrix(3,59)));
groebnerMatrix(8,61) = (groebnerMatrix(2,61)/(groebnerMatrix(2,59))-groebnerMatrix(3,61)/(groeb... | vmovsd 0x5290(%rdi), %xmm2
vmovsd 0x5130(%rdi), %xmm0
vmovsd 0x5138(%rdi), %xmm1
vdivsd %xmm0, %xmm2, %xmm2
vmovsd 0x5298(%rdi), %xmm3
vdivsd %xmm1, %xmm3, %xmm3
vsubsd %xmm3, %xmm2, %xmm2
vmovsd %xmm2, 0x52c0(%rdi)
vmovsd 0x53f0(%rdi), %xmm2
vdivsd %xmm0, %xmm2, %xmm2
vmovsd 0x53f8(%rdi), %xmm3
vdivsd %xmm1, %xmm3, %x... | /simogasp[P]opengv/src/absolute_pose/modules/gpnp5/spolynomials.cpp |
opengv::absolute_pose::modules::gpnp5::sPolynomial42(Eigen::Matrix<double, 44, 80, 0, 44, 80>&) | void
opengv::absolute_pose::modules::gpnp5::sPolynomial42( Eigen::Matrix<double,44,80> & groebnerMatrix )
{
groebnerMatrix(42,41) = (groebnerMatrix(11,41)/(groebnerMatrix(11,40))-groebnerMatrix(29,66)/(groebnerMatrix(29,65)));
groebnerMatrix(42,42) = (groebnerMatrix(11,42)/(groebnerMatrix(11,40))-groebnerMatrix(29,... | vmovsd 0x3758(%rdi), %xmm0
vmovsd 0x38b8(%rdi), %xmm1
vdivsd %xmm0, %xmm1, %xmm2
vmovsd 0x5ba8(%rdi), %xmm3
vmovsd 0x5a48(%rdi), %xmm1
vdivsd %xmm1, %xmm3, %xmm3
vsubsd %xmm3, %xmm2, %xmm2
vmovsd %xmm2, 0x39b0(%rdi)
vmovsd 0x3a18(%rdi), %xmm2
vdivsd %xmm0, %xmm2, %xmm2
vmovsd 0x5d08(%rdi), %xmm3
vdivsd %xmm1, %xmm3, %x... | /simogasp[P]opengv/src/absolute_pose/modules/gpnp5/spolynomials.cpp |
opengv::math::rot2quaternion(Eigen::Matrix<double, 3, 3, 0, 3, 3> const&) | opengv::quaternion_t
opengv::math::rot2quaternion( const rotation_t & R )
{
quaternion_t q;
q[0] = ( R(0,0) + R(1,1) + R(2,2) + 1.0) / 4.0;
q[1] = ( R(0,0) - R(1,1) - R(2,2) + 1.0) / 4.0;
q[2] = (-R(0,0) + R(1,1) - R(2,2) + 1.0) / 4.0;
q[3] = (-R(0,0) - R(1,1) + R(2,2) + 1.0) / 4.0;
if(q[0] < 0.0) q[0]... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
vmovsd (%rsi), %xmm0
vmovsd 0x20(%rsi), %xmm2
vaddsd %xmm2, %xmm0, %xmm1
vmovddup 0x40(%rsi), %xmm3 # xmm3 = mem[0,0]
vaddsd %xmm3, %xmm1, %xmm1
vmovsd 0x7cdc(%rip), %xmm4 # 0xfd040
vaddsd %xmm4, %xmm1, %xmm1
vmovsd 0x8818(%rip), %xmm5 ... | /simogasp[P]opengv/src/math/quaternion.cpp |
opengv::math::o4_roots(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&) | std::vector<double>
opengv::math::o4_roots( const Eigen::MatrixXd & p )
{
double A = p(0,0);
double B = p(1,0);
double C = p(2,0);
double D = p(3,0);
double E = p(4,0);
double A_pw2 = A*A;
double B_pw2 = B*B;
double A_pw3 = A_pw2*A;
double B_pw3 = B_pw2*B;
double A_pw4 = A_pw3*A;
double B_pw4 = B... | pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
vmovsd (%rax), %xmm12
vmovsd 0x8(%rax), %xmm13
vmovsd 0x10(%rax), %xmm0
vmovsd 0x18(%rax), %xmm1
vmovsd 0x20(%rax), %xmm2
vmulsd %xmm12, %xmm12, %xmm3
vmulsd %xmm13, %xmm13, %xmm4
vmulsd %xmm3, %xmm12, %xmm5
vmulsd %xmm4, %xmm13, %xmm6
... | /simogasp[P]opengv/src/math/roots.cpp |
opengv::generateRandomPointPlane() | Eigen::Vector3d
opengv::generateRandomPointPlane()
{
Eigen::Vector3d cleanPoint;
cleanPoint[0] = (((double) rand())/ ((double) RAND_MAX)-0.5)*2.0;
cleanPoint[1] = (((double) rand())/ ((double) RAND_MAX)-0.5)*2.0;
cleanPoint[2] = (((double) rand())/ ((double) RAND_MAX)-0.5)*2.0;
cleanPoint[0] = 6*cleanPoint[0... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2f060
movl %eax, %ebp
callq 0x2f060
movl %eax, %r14d
callq 0x2f060
vcvtsi2sd %eax, %xmm0, %xmm0
vdivsd 0x6777(%rip), %xmm0, %xmm0 # 0xfda38
vaddsd 0x68c7(%rip), %xmm0, %xmm0 # 0xfdb90
vaddsd %xmm0, %xmm0, %xmm0
vmovd %ebp, %xmm1
vpinsrd $0x1, %r14d, %xmm1, %xmm1
... | /simogasp[P]opengv/test/random_generators.cpp |
opengv::generateRandomRotation() | Eigen::Matrix3d
opengv::generateRandomRotation()
{
Eigen::Vector3d rpy;
rpy[0] = ((double) rand())/ ((double) RAND_MAX);
rpy[1] = ((double) rand())/ ((double) RAND_MAX);
rpy[2] = ((double) rand())/ ((double) RAND_MAX);
rpy[0] = 2*M_PI*(rpy[0]-0.5);
rpy[1] = M_PI*(rpy[1]-0.5);
rpy[2] = 2*M_PI*(rpy[2]-0.5)... | pushq %r14
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbx
callq 0x2f060
vcvtsi2sd %eax, %xmm0, %xmm0
vdivsd 0x63f5(%rip), %xmm0, %xmm0 # 0xfda38
vmovsd %xmm0, 0x8(%rsp)
callq 0x2f060
vcvtsi2sd %eax, %xmm1, %xmm0
vdivsd 0x63de(%rip), %xmm0, %xmm0 # 0xfda38
vmovsd %xmm0, 0x20(%rsp)
callq 0x2f060
vc... | /simogasp[P]opengv/test/random_generators.cpp |
opengv::getPerturbedPose(Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 1, 0, 3, 1>&, Eigen::Matrix<double, 3, 3, 0, 3, 3>&, double) | void
opengv::getPerturbedPose(
const translation_t & position,
const rotation_t & rotation,
translation_t & perturbedPosition,
rotation_t & perturbedRotation,
double amplitude )
{
perturbedPosition = position;
cayley_t cayley = math::rot2cayley(rotation);
for( size_t i = 0; i < 3; i++ )
{
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
vmovsd %xmm0, 0x8(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
vmovups (%rdi), %xmm0
vmovups %xmm0, (%rdx)
vmovsd 0x10(%rdi), %xmm0
vmovsd %xmm0, 0x10(%rdx)
leaq 0x10(%rsp), %rdi
callq 0xf50d0
xorl %r15d, %r15d
vmovsd (%r14,%r15,8), %xmm0
vmovsd %xmm0, (%rsp)
callq 0x2f060
vcv... | /simogasp[P]opengv/test/experiment_helpers.cpp |
opengv::generateRandom2D3DCorrespondences(Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, std::vector<Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::aligned_allocator<Eigen::Matrix<double, 3, 1, 0, 3, 1>>> const&, std::vector<Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::aligned_a... | void
opengv::generateRandom2D3DCorrespondences(
const translation_t & position,
const rotation_t & rotation,
const translations_t & camOffsets,
const rotations_t & camRotations,
size_t numberPoints,
double noise,
double outlierFraction,
bearingVectors_t & bearingVectors,
points_t & p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %r9, %rbx
vmovsd %xmm1, 0x118(%rsp)
vmovsd %xmm0, 0x88(%rsp)
movq %r8, 0x110(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, (%rsp)
movq 0x190(%rsp), %r15
cmpq $0x0, 0x10(%r15)
j... | /simogasp[P]opengv/test/experiment_helpers.cpp |
opengv::generateRandom2D2DCorrespondences(Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, std::vector<Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::aligned_allocator<Eigen::Matrix<double, 3... | void
opengv::generateRandom2D2DCorrespondences(
const translation_t & position1,
const rotation_t & rotation1,
const translation_t & position2,
const rotation_t & rotation2,
const translations_t & camOffsets,
const rotations_t & camRotations,
size_t numberPoints,
double noise,
double... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
vmovsd %xmm1, 0x110(%rsp)
vmovsd %xmm0, (%rsp)
movq %r9, 0xe0(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, 0xe8(%rsp)
movq %rdx, 0xd8(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdi, 0x120(%rsp)
movq 0x238(%rsp), %rbx
cmpq $0x0,... | /simogasp[P]opengv/test/experiment_helpers.cpp |
opengv::generateRandom3D3DCorrespondences(Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 1, 0, 3, 1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, unsigned long, double, double, std::vector<Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::aligned_al... | void
opengv::generateRandom3D3DCorrespondences(
const translation_t & position1,
const rotation_t & rotation1,
const translation_t & position2,
const rotation_t & rotation2,
size_t numberPoints,
double noise,
double outlierFraction,
bearingVectors_t & points1,
bearingVectors_t & poin... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, %r15
vmovsd %xmm1, 0xb8(%rsp)
vmovsd %xmm0, (%rsp)
movq %r8, 0xb0(%rsp)
movq %rcx, %rbx
movq %rdx, 0x78(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
movq 0x118(%rsp), %rbp
cmpq $0x0, 0x10(%rbp)
je 0xfa462
xorl %r14d, %r14d... | /simogasp[P]opengv/test/experiment_helpers.cpp |
timeval_minus(timeval const&, timeval const&) | timeval
timeval_minus( const struct timeval &t1, const struct timeval &t2 )
{
timeval ret;
ret.tv_sec = t1.tv_sec - t2.tv_sec;
if( t1.tv_usec < t2.tv_usec )
{
ret.tv_sec--;
ret.tv_usec = t1.tv_usec - t2.tv_usec + 1000000;
}
else
ret.tv_usec = t1.tv_usec - t2.tv_usec;
return ret;
} | movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq (%rsi), %rax
xorl %edi, %edi
subq 0x8(%rsi), %rcx
setl %dil
leaq 0xf4240(%rcx), %rdx
cmovgeq %rcx, %rdx
subq %rdi, %rax
retq
| /simogasp[P]opengv/test/time_measurement.cpp |
planandnavigatexythetalat(PlannerType, char*, char*, bool) | int planandnavigatexythetalat(PlannerType plannerType, char* envCfgFilename, char* motPrimFilename, bool forwardSearch)
{
double allocated_time_secs_foreachplan = 10.0; // in seconds
double initialEpsilon = 3.0;
bool bsearchuntilfirstsolution = false;
bool bforwardsearch = forwardSearch;
dou... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5c8, %rsp # imm = 0x5C8
movl %ecx, 0x1c(%rsp)
movq %rdx, %r12
movq %rsi, %r15
movl %edi, 0x38(%rsp)
leaq 0x1b0(%rsp), %rbx
movq %rbx, %rdi
callq 0x5430
movq 0x6e55(%rip), %r14 # 0xefd0
addq $0x10, %r14
movq %r14, (%rbx)
movl $0x0,... | /sbpl[P]sbpl/src/test/main.cpp |
planrobarm(PlannerType, char*, bool) | int planrobarm(PlannerType plannerType, char* envCfgFilename, bool forwardSearch)
{
int bRet = 0;
double allocated_time_secs = 5.0; //in seconds
MDPConfig MDPCfg;
bool bforwardsearch = forwardSearch;
//Initialize Environment (should be called before initializing anything else)
Environme... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movl %edx, %ebp
movl %edi, %ebx
xorl %eax, %eax
leaq 0x20(%rsp), %rdi
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x1, 0x20(%rdi)
movq 0x56b6(%rip), %rcx # 0xefb0
addq $0x10, %rcx
movq %rcx,... | /sbpl[P]sbpl/src/test/main.cpp |
main | int main(int argc, char *argv[])
{
// Print help
if (argc == 2 && strcmp(argv[1], "-h") == 0) {
PrintHelp(argv);
return MAIN_RESULT_SUCCESS;
}
else if (argc < 2) {
PrintUsage(argv);
return MAIN_RESULT_INSUFFICIENT_ARGS;
}
// Find the number of options... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movl %edi, %r15d
cmpl $0x2, %edi
jne 0x9d4d
movq 0x8(%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x9d7b
cmpb $0x68, 0x1(%rax)
jne 0x9d7b
cmpb $0x0, 0x2(%rax)
jne 0x9d7b
movq %rbx, %rdi
callq 0x5a9a
xorl %ebx, %ebx
jmp 0xa04a
jge 0... | /sbpl[P]sbpl/src/test/main.cpp |
DiscreteSpaceInformation::EnsureHeuristicsUpdated(bool) | virtual void EnsureHeuristicsUpdated(bool bGoalHeuristics)
{
// by default the heuristics are up-to-date, but in some cases, the
// heuristics are computed only when really needed. For example,
// xytheta environment uses 2D gridsearch as heuristics, and then
// re-computes them only... | retq
nop
| /sbpl[P]sbpl/src/include/sbpl/discrete_space_information/environment.h |
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 0x4712
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x471... | /dyna-dot[P]libyaml/src/api.c |
cxxopts::exceptions::option_already_exists::option_already_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit option_already_exists(const std::string& option)
: specification("Option " + LQUOTE + option + RQUOTE + " already exists")
{
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5f373(%rip), %rsi # 0x7e820
leaq 0x895dc(%rip), %rdx # 0xa8a90
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x1e78a
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x10170
leaq 0x18(%rsp), %r14
movq %... | /trolando[P]oink/src/tools/cxxopts.hpp |
pg::ZLKQSolver::solve(pg::bitset&, int, int, int) | void
ZLKQSolver::solve(bitset &SG, int vtop, const int pe, const int po)
{
/**
* This is based on a universal tree of height pr/2, with parameter n associated with pe or po
* We use several implementation tricks to make optimal use of memory and allocate as few as possible
* For example, we record pa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %r14d
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
incq 0x30(%rdi)
testl %r8d, %r8d
jle 0x4d5c9
movl %ecx, %r12d
testl %ecx, %ecx
jle 0x4d6c1
movl %r8d, %ebp
testl %r14d, %r14d
js 0x4d58c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl %r... | /trolando[P]oink/src/solvers/zlkq.cpp |
pg::NPPSolver::run() | void NPPSolver::run()
{
/* vv Stack initialization vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */
Phase.push_back(true);
Supgame.push_back(&outgame);
Heads.push_back(new uideque());
Exits.push_back(new bitset(nodecount()));
Entries.push_back(new uidlist());
Entries[0]->push_front(uideq... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
addq $0xb0, %rdi
movl $0x1, %esi
callq 0x50b4e
leaq 0xd8(%rbx), %rdi
leaq 0x60(%rbx), %rax
leaq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsp)
movq %rax, (%rsi)
callq 0x525fa
movl $0x50, %edi
callq 0x105a0
movq %rax, %r14
vxorps %... | /trolando[P]oink/src/solvers/npp.cpp |
pg::FPISolver::freezeThawReset(int, int, int) | void
FPISolver::freezeThawReset(int i, int n, int p)
{
const int pl = p&1;
for (; n != 0; i++, n--) {
if (disabled[i]) continue; // not in the subgame
if (frozen[i] >= p) continue; // already frozen
if (frozen[i]) {
if ((frozen[i]&1) == pl) {
frozen[i] = p;
... | testl %edx, %edx
je 0x59e0b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movslq %esi, %r15
movl $0x1, %r9d
movl %ebx, %r12d
andb $0x1, %r12b
movq 0x20(%r14), %rax
movq (%rax), %rcx
movq %r15, %rax
shrq $0x6, %rax
movq (%rcx,%rax,8), %... | /trolando[P]oink/src/solvers/fpi.cpp |
wabt::(anonymous namespace)::BinaryReaderObjdump::BinaryReaderObjdump(unsigned char const*, unsigned long, wabt::ObjdumpOptions*, wabt::ObjdumpState*) | BinaryReaderObjdump::BinaryReaderObjdump(const uint8_t* data,
size_t size,
ObjdumpOptions* options,
ObjdumpState* objdump_state)
: BinaryReaderObjdumpBase(data, size, options, objdump_state),
... | 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), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x58ff0
movq -0x30(%r... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpPrepass::BeginSection(unsigned int, wabt::BinarySection, unsigned long) | Result BeginSection(Index section_index,
BinarySection section_code,
Offset size) override {
BinaryReaderObjdumpBase::BeginSection(section_index, section_code, size);
if (section_code != BinarySection::Custom) {
objdump_state_->section_names.Set(section_index,
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x59f40
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x592f... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpPrepass::OnNameEntry(wabt::NameSectionSubsection, unsigned int, wabt::string_view) | Result OnNameEntry(NameSectionSubsection type,
Index index,
string_view name) override {
switch (type) {
// TODO(sbc): remove OnFunctionName in favor of just using
// OnNameEntry so that this works
/*
case NameSectionSubsection::Function:
Set... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
subl $0x5, %eax
je 0x5983f
jmp 0x5980f
movl -0x4c(%rbp), %eax
subl $0x... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::BeginFunctionBody(unsigned int, unsigned long) | Result BinaryReaderObjdumpDisassemble::BeginFunctionBody(Index index,
Offset size) {
printf("%06" PRIzx " func[%" PRIindex "]", state->offset, index);
auto name = GetFunctionName(index);
if (!name.empty()) {
printf(" <" PRIstringview ">", WABT_PRINTF_ST... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movl -0x14(%rbp), %edx
leaq 0x374ec(%rip), %rdi # 0x916a9
movb $0x0, %al
callq 0x39060
movq -0x38(%rbp), %rdi
movl... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdumpDisassemble::OnOpcodeIndex(unsigned int) | Result BinaryReaderObjdumpDisassemble::OnOpcodeIndex(Index value) {
Offset immediate_len = state->offset - current_opcode_offset;
string_view name;
if (current_opcode == Opcode::Call &&
!(name = GetFunctionName(value)).empty()) {
LogOpcode(immediate_len, "%d <" PRIstringview ">", value,
WA... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq 0x8(%rcx), %rax
movq 0x10(%rax), %rax
subq 0xf8(%rcx), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5e650
movq -0x60(%rbp), %rdi
addq $0xf0, %rdi
callq 0x63540
movl ... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::BeginSection(unsigned int, wabt::BinarySection, unsigned long) | Result BinaryReaderObjdump::BeginSection(Index section_index,
BinarySection section_code,
Offset size) {
BinaryReaderObjdumpBase::BeginSection(section_index, section_code, size);
// |section_name| and |match_name| are identical for k... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x59f40
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %edi
callq 0x6... | /dcodeIO[P]wabt/src/binary-reader-objdump.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.