name string | code string | asm string | file string |
|---|---|---|---|
cookiehash | static size_t cookiehash(const char * const domain)
{
const char *top;
size_t len;
if(!domain || isip(domain))
return 0;
top = get_top_domain(domain, &len);
return cookie_hash_domain(top, len);
} | testq %rdi, %rdi
je 0xef48
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xee16
testb %al, %al
je 0xef4b
xorl %eax, %eax
jmp 0xefce
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x9450
movq %rax, %r14
movq %rbx, %rdi
movl $0x2e, %esi
movq %rax, %rdx
callq 0x328d0
testq %rax, %rax
je 0xef8e
subq %rbx, %rax
movq %r... | /devkitPro[P]curl/lib/cookie.c |
Curl_cookie_clearall | void Curl_cookie_clearall(struct CookieInfo *cookies)
{
if(cookies) {
unsigned int i;
for(i = 0; i < COOKIE_HASH_SIZE; i++) {
Curl_cookie_freelist(cookies->cookies[i]);
cookies->cookies[i] = NULL;
}
cookies->numcookies = 0;
}
} | testq %rdi, %rdi
je 0xf531
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xf50d
movq (%rdi), %r15
callq 0xed27
movq %r15, %rdi
testq %r15, %r15
jne 0xf4fd
movq $0x0, (%rbx,%r14,8)
incq %r14
cmpq $0x100, %r14 # imm = 0x100
jne 0xf4f4
movq $0x0,... | /devkitPro[P]curl/lib/cookie.c |
Curl_flush_cookies | void Curl_flush_cookies(struct Curl_easy *data, bool cleanup)
{
if(data->set.str[STRING_COOKIEJAR]) {
if(data->change.cookielist) {
/* If there is a list of cookie files to read, do it first so that
we have all the told files read before we write the new jar.
Curl_cookie_loadfiles() LOCKS ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0xc48(%rdi)
je 0xf71d
cmpq $0x0, 0xf78(%rbx)
je 0xf6af
movq %rbx, %rdi
callq 0xdc68
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0x2e2da
movq 0xf90(%rbx), %r13
testq %r13, %r13
je 0xf75... | /devkitPro[P]curl/lib/cookie.c |
ftp_readresp | static CURLcode ftp_readresp(curl_socket_t sockfd,
struct pingpong *pp,
int *ftpcode, /* return the ftp-code if done */
size_t *size) /* size of the response */
{
struct connectdata *conn = pp->conn;
struct Curl_easy *data = conn... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq 0x58(%rsi), %r12
movq (%r12), %rbx
leaq 0x4(%rsp), %r15
movq %r15, %rdx
callq 0x377bf
movl (%r15), %ecx
movl %ecx, 0x1688(%rbx)
testq %r14, %r14
je 0x16381
movl %ecx, (%r14)
cmpl $0x1a5, %ecx # imm = 0x1A5
jne 0x163ab
leaq 0x3b10f(%r... | /devkitPro[P]curl/lib/ftp.c |
dprintf_DollarString | static long dprintf_DollarString(char *input, char **end)
{
int number = 0;
while(ISDIGIT(*input)) {
number *= 10;
number += *input-'0';
input++;
}
if(number && ('$'==*input++)) {
*end = input;
return number;
}
return 0;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %edi
callq 0x44040
xorl %r15d, %r15d
testl %eax, %eax
je 0x20d69
leal (%r15,%r15,4), %eax
movsbl (%r14), %ecx
leal (%rcx,%rax,2), %r15d
addl $-0x30, %r15d
movzbl 0x1(%r14), %edi
incq %r14
callq 0x44040
jmp 0x20d46
testl %r15d, %r15d
je 0x20... | /devkitPro[P]curl/lib/mprintf.c |
telnet_do | static CURLcode telnet_do(struct connectdata *conn, bool *done)
{
CURLcode result;
struct Curl_easy *data = conn->data;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
#ifdef USE_WINSOCK
HMODULE wsock2;
WSOCK2_FUNC close_event_func;
WSOCK2_EVENT create_event_func;
WSOCK2_FUNC event_select_func;
WSOCK2_F... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
movq (%rdi), %rbp
movl 0x4d8(%rdi), %r14d
movq 0x1150(%rbp), %rax
movq %rax, 0x30(%rsp)
movb $0x1, (%rsi)
leaq 0x48d44(%rip), %rax # 0x69b00
movl $0x1, %edi
movl $0x1ed0, %esi # imm... | /devkitPro[P]curl/lib/telnet.c |
telnet_done | static CURLcode telnet_done(struct connectdata *conn,
CURLcode status, bool premature)
{
struct TELNET *tn = (struct TELNET *)conn->data->req.protop;
(void)status; /* unused */
(void)premature; /* not used */
if(!tn)
return CURLE_OK;
curl_slist_free_all(tn->telnet_vars);... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x1d0(%rax), %r14
testq %r14, %r14
je 0x21c09
movq %rdi, %rbx
movq 0x1cb0(%r14), %rdi
callq 0x9d00
xorl %r15d, %r15d
movq %r15, 0x1cb0(%r14)
leaq 0x47ef5(%rip), %rax # 0x69ae8
movq (%rbx), %rcx
movq 0x1d0(%rcx), %rdi
callq *(%rax)
movq (%rbx), %rax
movq %r15, ... | /devkitPro[P]curl/lib/telnet.c |
printoption | static void printoption(struct Curl_easy *data,
const char *direction, int cmd, int option)
{
if(data->set.verbose) {
if(cmd == CURL_IAC) {
if(CURL_TELCMD_OK(option))
infof(data, "%s IAC %s\n", direction, CURL_TELCMD(option));
else
infof(data, "%s IAC %d\n", dir... | testb $0x40, 0xf63(%rdi)
jne 0x21e6d
retq
movl %ecx, %eax
movq %rsi, %r9
addl $0xffffff05, %edx # imm = 0xFFFFFF05
cmpl $0x4, %edx
ja 0x21ed1
leaq 0x30f08(%rip), %rcx # 0x52d8c
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leaq 0x30fe3(%rip), %rcx # 0x52e77
jmp 0x21ed8
leaq 0x30fe4(%rip), %rcx ... | /devkitPro[P]curl/lib/telnet.c |
hashkey | static void hashkey(struct connectdata *conn, char *buf,
size_t len, /* something like 128 is fine */
const char **hostp)
{
const char *hostname;
long port = conn->remote_port;
if(conn->bits.httpproxy && !conn->bits.tunnel_proxy) {
hostname = conn->http_proxy.host.nam... | movq %rsi, %rax
movl 0x624(%rdi), %esi
movl %esi, %ecx
andl $0x8040, %ecx # imm = 0x8040
cmpl $0x40, %ecx
jne 0x3c092
movq 0x400(%rdi), %rcx
addq $0x3d0, %rdi # imm = 0x3D0
jmp 0x3c0af
movslq 0x408(%rdi), %rcx
testb $0x8, %sil
jne 0x3c0a8
addq $0x340, %rdi # imm = 0x340
jmp 0x3c0af
addq ... | /devkitPro[P]curl/lib/conncache.c |
Curl_conncache_add_conn | CURLcode Curl_conncache_add_conn(struct conncache *connc,
struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct connectbundle *bundle;
struct connectbundle *new_bundle = NULL;
struct Curl_easy *data = conn->data;
/* *find_bundle() locks the connection cache */
bund... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbx
movq 0x1120(%rbx), %rsi
xorl %r12d, %r12d
movq %r15, %rdi
xorl %edx, %edx
callq 0x3bffa
movq %rax, %rbp
testq %rax, %rax
jne 0x3c1d3
leaq 0x2d9cf(%rip), %rax # 0x69ae0
movl $0x30, %ed... | /devkitPro[P]curl/lib/conncache.c |
Curl_conncache_remove_conn | void Curl_conncache_remove_conn(struct Curl_easy *data,
struct connectdata *conn, bool lock)
{
struct connectbundle *bundle = conn->bundle;
struct conncache *connc = data->state.conn_cache;
/* The bundle pointer can be NULL, since this function can be called
due to a failed c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x890(%rsi), %r12
testq %r12, %r12
je 0x3c2cc
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x1120(%rdi), %r15
testb %bpl, %bpl
je 0x3c282
cmpq $0x0, 0xd0(%rbx)
je 0x3c282
movq %rbx, %rdi
movl $0x5, %esi
movl $0x2, %edx
callq... | /devkitPro[P]curl/lib/conncache.c |
sigpipe_ignore | static void sigpipe_ignore(struct Curl_easy *data,
struct sigpipe_ignore *ig)
{
/* get a local copy of no_signal because the Curl_easy might not be
around when we restore */
ig->no_signal = data->set.no_signal;
if(!data->set.no_signal) {
struct sigaction action;
/* first, e... | movq 0xf60(%rdi), %rax
shrq $0x22, %rax
andb $0x1, %al
movb %al, 0x98(%rsi)
testb $0x4, 0xf64(%rdi)
jne 0x3c87a
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movl $0x98, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x95c0
movl $0xd, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x9d80
movq %rsp, %r14
movl $0x98, %e... | /devkitPro[P]curl/lib/sigpipe.h |
smb_send_setup | static CURLcode smb_send_setup(struct connectdata *conn)
{
struct smb_conn *smbc = &conn->proto.smbc;
struct smb_setup msg;
char *p = msg.bytes;
unsigned char lm_hash[21];
unsigned char lm[24];
unsigned char nt_hash[21];
unsigned char nt[24];
size_t byte_count = sizeof(lm) + sizeof(nt);
byte_count +=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movq %rdi, %rbx
movq 0x790(%rdi), %rdi
callq 0x9450
movq %rax, %r14
movq 0x798(%rbx), %rdi
callq 0x9450
leaq (%r14,%rax), %rcx
addq $-0x3c4, %rcx # imm = 0xFC3C
movl $0x3f, %eax
cmpq $-0x401, %rcx ... | /devkitPro[P]curl/lib/smb.c |
smb_send_message | static CURLcode smb_send_message(struct connectdata *conn, unsigned char cmd,
const void *msg, size_t msg_len)
{
CURLcode result = Curl_get_upload_buffer(conn->data);
if(result)
return result;
smb_format_message(conn, (struct smb_header *)conn->data->state.ulbuf,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x235a8
testl %eax, %eax
je 0x3dafb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
movq 0x1158(%rax), %r12
movq 0x1d0(%rax), %rax
xorps %xmm0, %xmm0
mo... | /devkitPro[P]curl/lib/smb.c |
smb_send | static CURLcode smb_send(struct connectdata *conn, ssize_t len,
size_t upload_size)
{
struct smb_conn *smbc = &conn->proto.smbc;
ssize_t bytes_written;
CURLcode result;
result = Curl_write(conn, FIRSTSOCKET, conn->data->state.ulbuf,
len, &bytes_written);
if(resu... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq 0x1158(%rax), %rdx
leaq 0x8(%rsp), %r8
xorl %esi, %esi
movq %r15, %rcx
callq 0x14c5e
testl %eax, %eax
jne 0x3dbf9
movq 0x8(%rsp), %rax
cmpq %r15, %rax
je 0x3dbf0
movq %r15, 0x7c8(%r14)
movq %rax, 0x7... | /devkitPro[P]curl/lib/smb.c |
Curl_mime_cleanpart | void Curl_mime_cleanpart(curl_mimepart *part)
{
cleanup_part_content(part);
curl_slist_free_all(part->curlheaders);
if(part->flags & MIME_USERHEADERS_OWNER)
curl_slist_free_all(part->userheaders);
Curl_safefree(part->mimetype);
Curl_safefree(part->name);
Curl_safefree(part->filename);
Curl_mime_initpa... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3dca5
movq 0x50(%rbx), %rdi
callq 0x9d00
testb $0x1, 0x80(%rbx)
je 0x3dc40
movq 0x58(%rbx), %rdi
callq 0x9d00
leaq 0x2bea1(%rip), %r14 # 0x69ae8
movq 0x60(%rbx), %rdi
callq *(%r14)
xorl %r15d, %r15d
movq %r15, 0x60(%rbx)
movq 0x70(%rbx), %rdi
callq *(%r14)
mo... | /devkitPro[P]curl/lib/mime.c |
curl_mime_filedata | CURLcode curl_mime_filedata(curl_mimepart *part, const char *filename)
{
CURLcode result = CURLE_OK;
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
cleanup_part_content(part);
if(filename) {
char *base;
struct_stat sbuf;
if(stat(filename, &sbuf) || access(filename, R_OK))
result = CURLE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
testq %rdi, %rdi
je 0x3e247
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3dca5
testq %r14, %r14
je 0x3e24e
movq %rsp, %rsi
movq %r14, %rdi
callq 0xa1b0
testl %eax, %eax
jne 0x3e1a4
movq %r14, %rdi
movl $0x4, %esi
callq 0xa120
testl %eax, %eax
je 0x3e2a5... | /devkitPro[P]curl/lib/mime.c |
curl_mime_data_cb | CURLcode curl_mime_data_cb(curl_mimepart *part, curl_off_t datasize,
curl_read_callback readfunc,
curl_seek_callback seekfunc,
curl_free_callback freefunc, void *arg)
{
if(!part)
return CURLE_BAD_FUNCTION_ARGUMENT;
cleanup_part_co... | testq %rdi, %rdi
je 0x3e306
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r15
callq 0x3dca5
xorl %eax, %eax
testq %rbp, %rbp
je 0x3e2f7
movq %rbp, 0x28(%r15)
movq %r13, 0x30(%r15)
movq %r14, 0x38(%r1... | /devkitPro[P]curl/lib/mime.c |
curl_mime_init | curl_mime *curl_mime_init(struct Curl_easy *easy)
{
curl_mime *mime;
mime = (curl_mime *) malloc(sizeof(*mime));
if(mime) {
mime->easy = easy;
mime->parent = NULL;
mime->firstpart = NULL;
mime->lastpart = NULL;
memset(mime->boundary, '-', 24);
if(Curl_rand_hex(easy, (unsigned char *) &m... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x2b7c6(%rip), %rax # 0x69ae0
movl $0x68, %edi
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x3e38a
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movaps 0x193ae(%rip), %xmm0 # 0x576f0
movups %xmm0, 0x20(%rbx)
movabsq ... | /devkitPro[P]curl/lib/mime.c |
curl_mime_addpart | curl_mimepart *curl_mime_addpart(curl_mime *mime)
{
curl_mimepart *part;
if(!mime)
return NULL;
part = (curl_mimepart *) malloc(sizeof(*part));
if(part) {
Curl_mime_initpart(part, mime->easy);
part->parent = mime;
if(mime->lastpart)
mime->lastpart->nextpart = part;
else
mime-... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3e40f
movq %rdi, %r14
leaq 0x2b72d(%rip), %rax # 0x69ae0
movl $0x1c8, %edi # imm = 0x1C8
callq *(%rax)
movq %rax, %rbx
testq %rax, %rax
je 0x3e411
movq (%r14), %r15
movl $0x1c8, %edx # imm = 0x1C8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x95... | /devkitPro[P]curl/lib/mime.c |
WienerFilterImpl(cv::Mat const&, cv::Mat&, double, cv::Size_<int> const&) | double WienerFilterImpl(const Mat& src, Mat& dst, double noiseVariance, const Size& block) {
assert(("Invalid block dimensions", block.width % 2 == 1 && block.height % 2 == 1 && block.width > 1 && block.height > 1));
assert(("src and dst must be one channel grayscale images", src.channels() == 1, dst.channels() == 1)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4e8, %rsp # imm = 0x4E8
movl (%rdx), %eax
movl %eax, %ecx
andl $0x80000001, %ecx # imm = 0x80000001
cmpl $0x1, %ecx
jne 0x2754
movq %rdx, %r13
movl 0x4(%rdx), %ecx
cmpl $0x2, %ecx
jl 0x2754
cmpl $0x2, %eax
jb 0x2754
andl $0x80000... | /prittt[P]AdaptiveWienerFilter/WienerFilter.cpp |
Catch::BinaryExpr<bool, bool>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movzbl 0xa(%rdi), %esi
leaq 0x28(%rsp), %rdi
callq 0x2230
movq 0x10(%r12), %r14
movq 0x18(%r12), %r15
movzbl 0x20(%r12), %esi
leaq 0x8(%rsp), %rdi
callq 0x2230
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r14... | /rezalas[P]riftshadow/tests/catch.hpp |
Catch::BinaryExpr<short const&, int const&>::streamReconstructedExpression(std::ostream&) const | void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1b620
movq 0x18(%r12), %r14
movq 0x20(%r12), %r15
movq 0x28(%r12), %rax
movl (%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x22d0
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %r8
movq %rbx... | /rezalas[P]riftshadow/tests/catch.hpp |
NGA_Periodic_acc | void NGA_Periodic_acc(int g_a, int lo[], int hi[], void* buf,int ld[], void* alpha)
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ndim);
COPYC2F(ld,_ga_work, nd... | subq $0x118, %rsp # imm = 0x118
movl %edi, 0x114(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq %rcx, 0xf8(%rsp)
movq %r8, 0xf0(%rsp)
movq %r9, 0xe8(%rsp)
movslq 0x114(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rdi
callq 0xd6ab0
movq %rax, 0xd8(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp)... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Pack64 | void GA_Pack64(int g_src, int g_dest, int g_mask, int64_t lo, int64_t hi, int64_t *icount)
{
Integer a = (Integer)g_src;
Integer b = (Integer)g_dest;
Integer s = (Integer)g_mask;
Integer icnt;
Integer alo = lo+1;
Integer ahi = hi+1;
wnga_pack(a, b, s, alo, ahi, &icnt);
*icount =... | subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x30(%rsp)
movslq 0x54(%rsp), %rax
movq %rax, 0x28(%rsp)
movslq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
addq $0x1, %r... | /GlobalArrays[P]ga/global/src/capi.c |
pnga_matmul | void pnga_matmul(transa, transb, alpha, beta,
g_a, ailo, aihi, ajlo, ajhi,
g_b, bilo, bihi, bjlo, bjhi,
g_c, cilo, cihi, cjlo, cjhi)
Integer g_a, ailo, aihi, ajlo, ajhi; /* patch of g_a */
Integer g_b, bilo, bihi, bjlo, bjhi; /* patch of g_b */
Integer g_c, cilo, cihi,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movq 0x4d0(%rsp), %rax
movq 0x4c8(%rsp), %rax
movq 0x4c0(%rsp), %rax
movq 0x4b8(%rsp), %rax
movq 0x4b0(%rsp), %rax
movq 0x4a8(%rsp), %rax
movq 0x4a0(%rsp), %rax
movq 0x498(%rsp), %rax
movq 0x490(%rsp), %rax
movq... | /GlobalArrays[P]ga/global/src/matmul.c |
gai_get_armci_memory | static DoubleComplex*
gai_get_armci_memory(Integer Ichunk, Integer Jchunk, Integer Kchunk,
short int nbuf, Integer atype) {
DoubleComplex *tmp = NULL;
Integer elems;
elems = (Integer) pow((double)BLOCK_SIZE,(double)2);
elems = nbuf*elems + nbuf*elems + elems; /* A,B,C temporary buffers */
... | subq $0x38, %rsp
movw %cx, %ax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movw %ax, 0x1e(%rsp)
movq %r8, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movsd 0x124f97(%rip), %xmm0 # 0x1718c8
movsd 0x124f97(%rip), %xmm1 # 0x1718d0
callq 0x3440
cvttsd2si %xmm0, %rax
movq %rax, (%rsp)
movswq 0x1e(%rsp), %rax
m... | /GlobalArrays[P]ga/global/src/matmul.c |
gai_get_task_list | static short int
gai_get_task_list(task_list_t *taskListA, task_list_t *taskListB,
task_list_t *state, Integer istart, Integer jstart,
Integer kstart, Integer iend, Integer jend, Integer kend,
Integer Ichunk, Integer Jchunk, Integer Kchunk,
int *max_tasks, Integer g_a) {
int ii, jj, nloops=0... | subq $0xd8, %rsp
movq 0x118(%rsp), %rax
movq 0x110(%rsp), %rax
movq 0x108(%rsp), %rax
movq 0x100(%rsp), %rax
movq 0xf8(%rsp), %rax
movq 0xf0(%rsp), %rax
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq %r9, 0xa8... | /GlobalArrays[P]ga/global/src/matmul.c |
sgai_set_diagonal_block | static void sgai_set_diagonal_block(Integer g_a, void *ptr, Integer g_v, Integer *loA,
Integer *hiA, Integer ld, Integer type)
{
Integer nelem, size;
Integer vlo, vhi, iloA, ihiA, jloA, jhiA, lo[2], hi[2];
Integer i;
void *buf;
int *ia;
float *fa;
double *da;
long *la;
Doub... | subq $0x118, %rsp # imm = 0x118
movq 0x120(%rsp), %rax
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq %rcx, 0xf8(%rsp)
movq %r8, 0xf0(%rsp)
movq %r9, 0xe8(%rsp)
movq 0xf8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xc0(%rsp)
movq 0xf0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xb8(%rs... | /GlobalArrays[P]ga/global/src/matrix.c |
snga_select_elem | static void snga_select_elem(Integer type, char* op, void *ptr, Integer elems, elem_info_t *info,
Integer *ind)
{
Integer i;
switch (type){
int *ia,ival;
double *da,dval;
DoubleComplex *ca;
SingleComplex *cfa;
float *fa,fval;
long *la,lval;
long long *lla,llval;
... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movq %r9, 0x88(%rsp)
movq 0xb0(%rsp), %rax
addq $-0x3e9, %rax # imm = 0xFC17
movq %rax, (%rsp)
subq $0xf, %rax
ja 0x60d57
movq (%rsp), %rax
leaq 0x112992(%rip), %rcx # 0x172c80
movs... | /GlobalArrays[P]ga/global/src/select.c |
pnga_sprs_array_add_element | void pnga_sprs_array_add_element(Integer s_a, Integer idx, Integer jdx, void *val)
{
Integer hdl = GA_OFFSET + s_a;
Integer nval = SPA[hdl].nval;
Integer size = SPA[hdl].size;
Integer idx_size = sizeof(Integer);
/* Check to see if array is active and not ready */
if (!SPA[hdl].active)
pnga_error("(ga_s... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x50(%rsp)
leaq 0x10f281(%rip), %rax # 0x1954c0
movq (%rax), %rax
imulq $0xc8, 0x50(%rsp), %rcx
addq %rcx, %rax
movq 0x98(%rax), %rax
mo... | /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_access_col_block | void pnga_sprs_array_access_col_block(Integer s_a, Integer icol,
void *idx, void *jdx, void *val)
{
Integer hdl = GA_OFFSET + s_a;
char *lptr;
Integer i,index;
Integer longidx;
if (SPA[hdl].idx_size == sizeof(int64_t)) {
longidx = 1;
} else {
longidx = 0;
}
index = -1;
for (i=0; i<SPA[hdl]... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0xa0(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x78(%rsp)
leaq 0x10b1f7(%rip), %rax # 0x1954c0
movq (%rax), %rax
imulq $0xc8, 0x78(%rsp), %rcx
addq %rcx, %rax
cmp... | /GlobalArrays[P]ga/global/src/sparse.array.c |
MA_get_mbase | public Pointer MA_get_mbase(Integer datatype) /* to get base address of */
{
#ifdef STATS
ma_stats.calls[(int)FID_MA_get_mbase]++;
#endif /* STATS */
/* preinitialize if necessary */
ma_preinitialize("MA_get_mbase");
/* verify datatype */
if (!mt_valid(datatype))
{
(void)sprintf(ma_... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0xdf418(%rip), %rax # 0x195548
addq $0x1, %rax
movq %rax, 0xdf40d(%rip) # 0x195548
leaq 0xbf5b2(%rip), %rdi # 0x1756f4
callq 0xb61d0
cmpq $0x3e8, 0x8(%rsp) # imm = 0x3E8
jl 0xb615d
cmpq $0x3f8, 0x8(%rsp) # imm = 0x3F8
jle 0xb6199
movq 0x8(%rsp), %rdx
le... | /GlobalArrays[P]ga/ma/ma.c |
list_member | private Boolean list_member(ad, list)
AD *ad; /* the AD to search for */
AD *list; /* the list to search */
{
AD *ad1; /* traversal pointer */
for (ad1 = list; ad1; ad1 = ad1->next)
if (ad1 == ad)
/* ad is a member of list */
ret... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0xb8065
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jne 0xb8053
movq $0x1, -0x8(%rsp)
jmp 0xb806e
jmp 0xb8055
movq -0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xb8034
movq $0x0,... | /GlobalArrays[P]ga/ma/ma.c |
PARMCI_Init | int PARMCI_Init()
{
int rc = comex_init();
assert(COMEX_SUCCESS == rc);
rc = comex_group_comm(COMEX_GROUP_WORLD, &ARMCI_COMM_WORLD);
assert(COMEX_SUCCESS == rc);
ARMCI_Default_Proc_Group = 0;
armci_init_domains(ARMCI_COMM_WORLD);
return rc;
} | pushq %rax
movb $0x0, %al
callq 0xc1120
movl %eax, 0x4(%rsp)
xorl %eax, %eax
cmpl 0x4(%rsp), %eax
jne 0xb9ab6
jmp 0xb9ad5
leaq 0xbc527(%rip), %rdi # 0x175fe4
leaq 0xbc4a2(%rip), %rsi # 0x175f66
movl $0x196, %edx # imm = 0x196
leaq 0xbc617(%rip), %rcx # 0x1760e7
callq 0x3150
xorl %edi, %edi
leaq 0... | /GlobalArrays[P]ga/comex/src-armci/armci.c |
PARMCI_PutS | int PARMCI_PutS(void *src_ptr, int *src_stride_arr, void *dst_ptr, int *dst_stride_arr, int *count, int stride_levels, int proc)
{
int iret;
/* check if data is contiguous */
if (armci_check_contiguous(src_stride_arr, dst_stride_arr, count, stride_levels)) {
int i;
int lcount = 1;
for (i=0; i<=stride_... | subq $0x48, %rsp
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0xb90c0
cmpl $0x0, %eax
je 0xba6e0
movl $0x1, 0x10(%rsp)... | /GlobalArrays[P]ga/comex/src-armci/armci.c |
armci_msg_gop_scope | void armci_msg_gop_scope(int scope, void *x, int n, char* op, int type)
{
if (SCOPE_NODE == scope) {
if (_number_of_procs_per_node > 1) {
do_gop(x, n, op, type, ARMCI_Node_group);
} else {
do_gop(x, n, op, type, ARMCI_GROUP_SELF);
}
} else {
do_gop(x, n, op, type, get_d... | subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movl $0x151, %eax # imm = 0x151
cmpl 0x44(%rsp), %eax
jne 0xbc9c5
leaq 0xd3bd3(%rip), %rax # 0x190550
cmpl $0x1, (%rax)
jle 0xbc9a5
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
mo... | /GlobalArrays[P]ga/comex/src-armci/message.c |
mq_pop | static void _mq_pop()
{
message_t *mq_to_delete = NULL;
assert(l_state.mq_head);
assert(l_state.mq_tail);
assert(l_state.mq_head->request == MPI_REQUEST_NULL);
mq_to_delete = l_state.mq_head;
l_state.mq_head = l_state.mq_head->next;
/* don't need message or request any longer */
_my_f... | pushq %rax
movq $0x0, (%rsp)
leaq 0xd7c20(%rip), %rax # 0x195bd0
cmpq $0x0, 0x20(%rax)
je 0xbdfb9
jmp 0xbdfd8
leaq 0xb902b(%rip), %rdi # 0x176feb
leaq 0xb8b33(%rip), %rsi # 0x176afa
movl $0xe1, %edx
leaq 0xb9074(%rip), %rcx # 0x177047
callq 0x3150
leaq 0xd7bf1(%rip), %rax # 0x195bd0
cmpq $0x0, 0x28(... | /GlobalArrays[P]ga/comex/src-mpi/comex.c |
comex_rmw | int comex_rmw(
int comex_op, void *ploc, void *prem, int extra,
int proc, comex_group_t group)
{
header_t *header = NULL;
char *notify = NULL;
char *payload = NULL;
char *message = NULL;
int length = 0;
op_t op;
long extra_long = (long)extra;
CHECK_GROUP(group,proc);
#if... | subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movl %r8d, 0x58(%rsp)
movl %r9d, 0x54(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movslq 0x5c(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x54(%rsp)... | /GlobalArrays[P]ga/comex/src-mpi/comex.c |
comex_unlock | int comex_unlock(int mutex, int proc)
{
#if DEBUG
printf("[%d] comex_unlock id=%d proc=%d\n", l_state.rank, mutex, proc);
#endif
header_t *header = NULL;
header = _my_malloc(sizeof(header_t));
header->operation = OP_UNLOCK;
header->remote_address = NULL;
header->local_address = NULL;
header... | subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x28, %edi
callq 0xbe0f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x13, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%r... | /GlobalArrays[P]ga/comex/src-mpi/comex.c |
pnga_initialize | void pnga_initialize()
{
Integer i, j,nproc, nnode, zero;
int bytes;
GA_Internal_Threadsafe_Lock();
#ifdef MSG_COMMS_MPI
MPI_Comm comm;
#endif
if(GAinitialized)
{
GA_Internal_Threadsafe_Unlock();
return;
}
#if HAVE_ARMCI_INITIALIZED_FUNCTION
if (!ARMCI_Initialized(... | subq $0x68, %rsp
cmpl $0x0, 0xd2605(%rip) # 0x195cf0
je 0xc36f2
jmp 0xc3ff2
cmpl $0x0, 0xd25fb(%rip) # 0x195cf4
jne 0xc3801
cmpq $0x0, 0xd25f1(%rip) # 0x195cf8
je 0xc3715
movq 0xcce78(%rip), %rdi # 0x190588
callq 0xbac30
leaq 0xcdec0(%rip), %rax # 0x1915dc
cmpl $0x0, (%rax)
je 0xc3754
leaq 0xcdeb0(%... | /GlobalArrays[P]ga/global/src/base.c |
pnga_pgroup_split_irreg | Integer pnga_pgroup_split_irreg(Integer grp, Integer mycolor)
{
Integer nprocs, me, default_grp, grp_id;
Integer i, icnt=0;
Integer *nodes, *color_arr;
/* Allocate temporary arrays */
nodes = (Integer*)malloc(GAnproc*sizeof(Integer));
color_arr = (Integer*)malloc(GAnproc*sizeof(Integer));
if(mycolo... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq $0x0, 0x18(%rsp)
leaq 0xcb70a(%rip), %rax # 0x195d98
movq (%rax), %rdi
shlq $0x3, %rdi
callq 0x3340
movq %rax, 0x10(%rsp)
leaq 0xcb6f2(%rip), %rax # 0x195d98
movq (%rax), %rdi
shlq $0x3, %rdi
callq 0x3340
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x48(%rsp... | /GlobalArrays[P]ga/global/src/base.c |
pnga_set_data | void pnga_set_data(Integer g_a, Integer ndim, Integer *dims, Integer type)
{
Integer i;
Integer ga_handle = g_a + GA_OFFSET;
if (GA[ga_handle].actv == 1)
pnga_error("Cannot set data on array that has been allocated",0);
gam_checkdim(ndim, dims);
gam_checktype(pnga_type_f2c(type));
GA[ga_handle].type = ... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x8(%rsp)
leaq 0xcb199(%rip), %rax # 0x195cb8
movq (%rax), %rax
imulq $0x368, 0x8(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
cmpl $0x1, ... | /GlobalArrays[P]ga/global/src/base.c |
pnga_set_restricted | void pnga_set_restricted(Integer g_a, Integer *list, Integer size)
{
Integer i, ig, id=0, me, p_handle, has_data, nproc;
Integer ga_handle = g_a + GA_OFFSET;
GA[ga_handle].num_rstrctd = size;
GA[ga_handle].rstrctd_list = (Integer*)malloc(size*sizeof(Integer));
GA[ga_handle].rank_rstrctd = (Integer*)malloc((GA... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x50(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, (%rsp)
movq 0x40(%rsp), %rcx
leaq 0xc97a1(%rip), %rax # 0x195cb8
movq (%rax), %rax
imulq $0x368, (%rsp), %rdx # imm = 0x368
addq %rd... | /GlobalArrays[P]ga/global/src/base.c |
gai_getmem | int gai_getmem(char* name, char **ptr_arr, C_Long bytes, int type, long *id,
int grp_id)
{
#ifdef AVOID_MA_STORAGE
return gai_get_shmem(ptr_arr, bytes, type, id, grp_id);
#else
Integer handle = INVALID_MA_HANDLE, index;
Integer nproc=GAnproc, grp_me=GAme, item_size = GAsizeofM(type);
C_Long nelem;
char *ptr ... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %r8d
callq 0xd63a0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| /GlobalArrays[P]ga/global/src/base.c |
calc_maplen | static int calc_maplen(int handle)
{
if (GA[handle].mapc != NULL) {
int i,len=0;
if (GA[handle].distr_type != TILED_IRREG) {
for (i=0; i<GA[handle].ndim; i++) {
len += GA[handle].nblock[i];
}
} else {
for (i=0; i<GA[handle].ndim; i++) {
l... | movl %edi, -0x8(%rsp)
leaq 0xbe6ad(%rip), %rax # 0x195cb8
movq (%rax), %rax
movslq -0x8(%rsp), %rcx
imulq $0x368, %rcx, %rcx # imm = 0x368
addq %rcx, %rax
cmpq $0x0, 0x1e8(%rax)
je 0xd7734
movl $0x0, -0x10(%rsp)
leaq 0xbe67e(%rip), %rax # 0x195cb8
movq (%rax), %rax
movslq -0x8(%rsp), %rcx
imulq $0x368, %rc... | /GlobalArrays[P]ga/global/src/base.c |
pnga_randomize | void pnga_randomize(Integer g_a, void* val)
{
int i,handle=GA_OFFSET + (int)g_a;
char *ptr;
int local_sync_begin,local_sync_end;
C_Long elems;
Integer grp_id;
Integer num_blocks;
local_sync_begin = _ga_sync_begin; local_sync_end = _ga_sync_end;
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous... | subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq 0x2a0(%rsp), %rax
addl $0x3e8, %eax # imm = 0x3E8
movl %eax, 0x290(%rsp)
leaq 0xb7f8e(%rip), %rax # 0x190570
movl (%rax), %eax
movl %eax, 0x284(%rsp)
leaq 0xb7f82(%rip), %rax # 0x190574
movl (%rax), %eax
mov... | /GlobalArrays[P]ga/global/src/base.c |
pnga_get_proc_index | void pnga_get_proc_index(Integer g_a, Integer iproc, Integer *index)
{
Integer ga_handle = GA_OFFSET + g_a;
if (GA[ga_handle].distr_type == SCALAPACK) {
gam_find_proc_indices(ga_handle, iproc, index);
} else if (GA[ga_handle].distr_type == TILED ||
GA[ga_handle].distr_type == TILED_IRREG) {
gam_find... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x38(%rsp)
leaq 0xb457e(%rip), %rax # 0x195cb8
movq (%rax), %rax
imulq $0x368, 0x38(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
cmpl $0x2, 0x224(%rax)
jne 0xe1... | /GlobalArrays[P]ga/global/src/base.c |
pnga_scatter2d | void pnga_scatter2d(Integer g_a, void *v, Integer *i, Integer *j, Integer nv)
{
register Integer k;
Integer kk;
Integer item_size;
Integer proc, type=GA[GA_OFFSET + g_a].type;
Integer nproc, p_handle, iproc;
Integer subscrpt[2];
Integer *aproc, naproc; /* active processes and numbers */
... | pushq %rbx
subq $0xa10, %rsp # imm = 0xA10
movq %rdi, 0xa08(%rsp)
movq %rsi, 0xa00(%rsp)
movq %rdx, 0x9f8(%rsp)
movq %rcx, 0x9f0(%rsp)
movq %r8, 0x9e8(%rsp)
leaq 0xa6e91(%rip), %rax # 0x195cb8
movq (%rax), %rax
movq 0xa08(%rsp), %rcx
addq $0x3e8, %rcx # imm = 0x3E8
imulq $0x368, %rcx, %rcx ... | /GlobalArrays[P]ga/global/src/onesided.c |
gai_SetStrideWithSkip | void gai_SetStrideWithSkip(Integer ndim, Integer size, Integer *ld,
Integer *ldrem, int *stride_rem,
int *stride_loc, Integer *skip)
{
#if 1
int i;
stride_rem[0] = stride_loc[0] = (int)size;
for (i=0; i<ndim; i++) {
stride_rem[i+1] = stride_rem[i];
strid... | movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x10(%rsp), %rax
movl %eax, %ecx
movq -0x30(%rsp), %rax
movl %ecx, (%rax)
movq -0x28(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, -0x34(%rsp)
movslq -0x34(%rsp), ... | /GlobalArrays[P]ga/global/src/onesided.c |
pnga_update4_ghosts | logical pnga_update4_ghosts(Integer g_a)
{
Integer idx, i, handle=GA_OFFSET + g_a;
Integer *size, bufsize, buflen, ndim, elemsize;
Integer *proc_rem_snd, *proc_rem_rcv, pmax;
Integer msgcnt, *length;
Integer index[MAXDIM], width[MAXDIM];
int *stride_snd, *stride_rcv, *count, msglen;
char **ptr_snd, **ptr_... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x198(%rsp)
movq 0x198(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x180(%rsp)
movb $0x0, %al
callq 0xdf730
movq %rax, 0x8(%rsp)
movq 0x198(%rsp), %rdi
callq 0xd6a70
cmpq $0x0, %rax
jne 0x11e205
movq $0x1, 0x1a0(%rsp)
jmp 0x11edde
leaq 0x77aac(... | /GlobalArrays[P]ga/global/src/ghosts.c |
pnga_nbget_ghost_dir | void pnga_nbget_ghost_dir(Integer g_a,
Integer *mask,
Integer *nbhandle)
{
Integer handle = GA_OFFSET + g_a;
Integer lo_loc[MAXDIM], hi_loc[MAXDIM], lo_rem[MAXDIM], hi_rem[MAXDIM];
Integer subscript[MAXDIM], ld[MAXDIM];
Integer i, ndim, dim, width;
... | subq $0x358, %rsp # imm = 0x358
movq %rdi, 0x350(%rsp)
movq %rsi, 0x348(%rsp)
movq %rdx, 0x340(%rsp)
movq 0x350(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x338(%rsp)
movb $0x0, %al
callq 0xdf730
movq %rax, 0x190(%rsp)
leaq 0x5500d(%rip), %rax # 0x195cb8
movq (%rax), %rax
imulq $0x... | /GlobalArrays[P]ga/global/src/ghosts.c |
ga_sadd_patch_ | void FATR ga_sadd_patch_(Real *alpha, Integer *g_a, Integer *ailo, Integer *aihi, Integer *ajlo, Integer *ajhi, Real *beta, Integer *g_b, Integer *bilo, Integer *bihi, Integer *bjlo, Integer *bjhi, Integer *g_c, Integer *cilo, Integer *cihi, Integer *cjlo, Integer *cjhi)
{
Integer atype, btype, ctype;
pnga_inq... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq 0x140(%rsp), %rax
movq 0x138(%rsp), %rax
movq 0x130(%rsp), %rax
movq 0x128(%rsp), %rax
movq 0x120(%rsp), %rax
movq 0x118(%rsp), %rax
movq 0x110(%rsp), %rax
movq 0x108(%rsp), %rax
movq 0x100(%rsp), %rax
movq 0xf8(%rsp), %rax
movq 0xf... | /GlobalArrays[P]ga/global/src/fapi.c |
ga_sort_scat_dcpl_ | static void ga_sort_scat_dcpl_(pn, v, i, j, base)
Integer *pn;
DoubleComplex *v;
Integer *i;
Integer *j;
Integer *base;
{
if (*pn < 2) return;
# undef SWAP
# define SWAP(a,b) { \
Integer ltmp; \
DoubleComplex dtmp; \
long ia = a - base; \
long ib = b - base; \
ltmp=*... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
cmpq $0x2, (%rax)
jge 0x1539dd
jmp 0x153fc3
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
addq $-0x8, %rax
movq %rax, -0x8(%rsp)
movq (%rs... | /GlobalArrays[P]ga/global/src/hsort.scat.c |
f2c_alloc_get_ | FATR f2c_alloc_get_(datatype, nelem, name, memhandle, index, namesize)
Integer *datatype;
Integer *nelem;
char *name;
Integer *memhandle;
MA_AccessIndex *index;
int namesize; /* implicitly passed by FORTRAN */
#else /* F2C_HIDDEN_STRING_LENGTH_AFTER_ARGS */
public Boolean FATR f2c_alloc_ge... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq %rsp, %rdx
movl $0x20, %ecx
callq 0x162270
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
... | /GlobalArrays[P]ga/ma/f2c.c |
bsp_abort_va | void bsp_abort_va( const char * format, va_list ap )
{
int mpi_init = 0;
MPI_Initialized( & mpi_init );
s_aborting = true;
if (s_expect_abort_msg) {
char buffer[200];
std::vsnprintf(buffer, sizeof(buffer), format, ap );
size_t len = strlen( s_expect_abort_msg );
if (len... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %rdi
movl $0x0, (%rdi)
callq 0x5140
movb $0x1, 0x10802(%rip) # 0x162c0
cmpq $0x0, 0x107f2(%rip) # 0x162b8
je 0x5b2f
leaq 0x10(%rsp), %r15
movl $0xc8, %r12d
movl $0xc8, %esi
movq %r15, %rdi
mov... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsp_sync | void bsp_sync()
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_sync: can only be called within SPMD section\n");
if (s_spmd->normal_sync())
bsp_abort("bsp_sync/bsp_end: Some processes have called bsp_sync, "
"while others have called bsp_end instead\n");
#ifdef PROFILE
{ ... | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq 0xffb5(%rip), %rax # 0x162c8
testq %rax, %rax
je 0x631e
cmpb $0x1, 0x8(%rax)
jne 0x632c
leaq 0x932f(%rip), %rdi # 0xf654
xorl %eax, %eax
callq 0x5a09
movq 0xff95(%rip), %rdi # 0x162c8
callq 0x81fc
testl %eax, %eax
je 0x634a
leaq 0x91b2(%rip), %rdi # 0xf4f5... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsp_put | void bsp_put( bsp_pid_t pid, const void * src, void * dst,
bsp_size_t offset, bsp_size_t nbytes )
{
#ifdef PROFILE
TicToc t( TicToc::PUT, nbytes );
#endif
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_put: can only be called within SPMD section\n");
if (nbytes == 0) // ignore any empty w... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r14
movl %edi, %ebp
movq 0xfd5f(%rip), %rax # 0x162c8
testq %rax, %rax
je 0x6574
cmpb $0x1, 0x8(%rax)
jne 0x6582
leaq 0x91e5(%rip), %rdi # 0xf760
xorl %eax, %eax
callq 0x5a09
testl %ebx, %ebx
je... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsp_get | void bsp_get( bsp_pid_t pid, const void * src, bsp_size_t offset,
void * dst, bsp_size_t nbytes )
{
#ifdef PROFILE
TicToc t( TicToc::GET, nbytes );
#endif
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_get: can only be called within SPMD section\n");
if (nbytes == 0) // ignore any empty r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %r14d
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r12
movl %edi, %ebp
movq 0xf9e3(%rip), %rax # 0x162c8
testq %rax, %rax
je 0x68f0
cmpb $0x1, 0x8(%rax)
jne 0x68fe
leaq 0x912d(%rip), %rdi # 0xfa24
xorl %eax, %eax
callq 0x5a09
testl %r14d, %r14d... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
mcbsp_hpget | void mcbsp_hpget( mcbsp_pid_t pid, const void * src,
mcbsp_size_t offset, const void * dst, mcbsp_size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::HPGET, size );
#endif
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_hpget: can only be called within SPMD section\n");
if (size == 0) // ignore ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebp
movq 0xef79(%rip), %rax # 0x162c8
testq %rax, %rax
je 0x735a
cmpb $0x1, 0x8(%rax)
jne 0x7368
leaq 0x8813(%rip), %rdi # 0xfb74
xorl %eax, %eax
callq 0x5a09... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
mcbsp_set_tagsize | void mcbsp_set_tagsize( mcbsp_size_t * size )
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_set_tagsize: can only be called within SPMD section\n");
if (size == NULL)
bsp_abort("bsp_set_tagsize: NULL ptr as argument is now allowed\n");
*size = s_bsmp->set_tag_size( *size );
} | pushq %rbx
movq %rdi, %rbx
movq 0xee5a(%rip), %rax # 0x162c8
testq %rax, %rax
je 0x7479
cmpb $0x1, 0x8(%rax)
jne 0x7487
leaq 0x8804(%rip), %rdi # 0xfc84
xorl %eax, %eax
callq 0x5a09
testq %rbx, %rbx
jne 0x749a
leaq 0x882a(%rip), %rdi # 0xfcbd
xorl %eax, %eax
callq 0x5a09
movq 0xee37(%rip), %rax # 0x... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
mcbsp_move | void mcbsp_move( void * payload, mcbsp_size_t reception_bytes )
{
if (!s_spmd || s_spmd->closed())
bsp_abort("bsp_move: can only be called within SPMD section\n");
if ( payload == NULL && reception_bytes > 0 )
bsp_abort("bsp_move: payload may not be NULL if size parameter is non-zero\n");
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xec18(%rip), %rax # 0x162c8
testq %rax, %rax
je 0x76bb
cmpb $0x1, 0x8(%rax)
jne 0x76c9
leaq 0x8962(%rip), %rdi # 0x10024
xorl %eax, %eax
callq 0x5a09
testq %r14, %r14
setne %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x76e7
leaq 0x8a6c(... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bool bsplib::read_env<int>(char const*, int&) | bool read_env( const char * str, T & result ) {
#if HAS_DUPENV_S_WIN32
char * env = NULL;
if (_dupenv_s( &env, NULL , str) )
return false;
#else
const char * env = std::getenv( str );
#endif
if (env) {
std::istringstream s( env );
#if HAS_DUPENV_S_WIN32
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %rbx
callq 0x5310
testq %rax, %rax
je 0x7905
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, %rdi
callq 0x50d0
movq %r14, %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7fc4
leaq 0x20(%rsp), %rdi... | /wijnand-suijlen[P]bsponmpi/src/config.h |
bsplib::Rdma::lookup_reg(void const*, bool, bool) const | Memslot lookup_reg( const void * addr, bool pushed, bool popped ) const
{
if (addr == NULL ) return null_slot();
if ( m_cached_slot != no_slot()
&& slot( m_pid, m_cached_slot).addr == addr
&& slot( m_pid, m_cached_slot).status == Memblock::NORMAL )
... | testq %rsi, %rsi
je 0x7dad
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %r8d
movq 0x368(%rdi), %rax
cmpq $-0x1, %rax
je 0x7d50
movslq 0x2f4(%rdi), %rdx
imulq %rax, %rdx
leaq (%rdx,%rdx,2), %rdx
shlq $0x3, %rdx
addq 0x338(%rdi), %rdx
movslq 0x2f0(%rdi), %r9
leaq (%r9,%r9,2), %r9
cmpq %rsi, (%rdx,%r9,8)
jne 0x7... | /wijnand-suijlen[P]bsponmpi/src/rdma.h |
bsplib::Spmd::Spmd(int) | Spmd :: Spmd( int nprocs )
{
int mpi_init;
int world_pid = -1;
MPI_Initialized(&mpi_init);
assert( mpi_init );
MPI_Bcast( &nprocs, 1, MPI_INT, 0, MPI_COMM_WORLD );
MPI_Comm_rank( MPI_COMM_WORLD, & world_pid );
m_closed = false;
m_active = world_pid < nprocs;
MPI_Comm_split( MP... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %r14
movq %r14, %rdi
callq 0x5140
cmpl $0x0, (%r14)
je 0x810f
movq 0xdf34(%rip), %rdx # 0x15fc0
movq 0xdefd(%rip), %r14 # 0x15f90
leaq 0x10(%rsp),... | /wijnand-suijlen[P]bsponmpi/src/spmd.cc |
sptk::ReadStream(sptk::SymmetricMatrix*, std::istream*) | bool ReadStream(sptk::SymmetricMatrix* matrix_to_read,
std::istream* input_stream) {
if (NULL == matrix_to_read) {
return false;
}
const int dim(matrix_to_read->GetNumDimension());
sptk::Matrix matrix(dim, dim);
if (!sptk::ReadStream(&matrix, input_stream)) {
return false;
}
for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rdi, %rdi
je 0x35cc
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdi), %edx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movl %edx, %esi
movq %rdx, %r14
callq 0x7ed0
movq %r12, %rdi
movq %r15, %rsi
callq 0x3490
movl %eax, 0xc(%rsp)
testb %a... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int, int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::ostrea... | bool WriteStream(int write_point, int write_size,
const std::vector<std::string>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
je 0x3704
xorl %r13d, %r13d
jmp 0x3787
movq %rdx, %r15
movl %esi, %r12d
movl %edi, %ebp
movq 0x8(%rdx), %rax
subq (%rdx), ... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::SnPrintf<sptk::uint24_t>(sptk::uint24_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, char*) | bool SnPrintf(uint24_t data, const std::string& print_format,
std::size_t buffer_size, char* buffer) {
if (print_format.empty() || 0 == buffer_size || NULL == buffer) {
return false;
}
return (std::snprintf(buffer, buffer_size, print_format.c_str(),
static_cast<int>(data... | xorl %eax, %eax
testq %rcx, %rcx
je 0x381d
testq %rdx, %rdx
je 0x381d
cmpq $0x0, 0x8(%rsi)
je 0x381d
pushq %rax
movq (%rsi), %rax
movzwl 0x1(%rdi), %esi
shll $0x8, %esi
movzbl (%rdi), %r8d
orl %esi, %r8d
movq %rcx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movl %r8d, %ecx
xorl %eax, %eax
callq 0x2350
testl %eax, %eax
setns ... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::ConvertStringToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double*) | bool ConvertStringToDouble(const std::string& input, double* output) {
if (input.empty() || NULL == output) {
return false;
}
char* end;
double converted_value(std::strtod(input.c_str(), &end));
if (0 == input.compare(end) || '\0' != *end || ERANGE == errno) {
return false;
}
*output = converte... | xorl %eax, %eax
testq %rsi, %rsi
je 0x38fb
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x38f2
movq %rsi, %rbx
movq (%r14), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x21d0
movsd %xmm0, (%rsp)
movq (%r15), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x20d0
testl %eax, %... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::NextPowTwo(int) | int NextPowTwo(int num) {
num--;
num |= num >> 1;
num |= num >> 2;
num |= num >> 4;
num |= num >> 8;
num |= num >> 16;
num++;
return num;
} | leal -0x1(%rdi), %eax
movl %eax, %ecx
sarl %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %edx
sarl $0x8, %edx
orl %ecx, %edx
movl %edx, %eax
sarl $0x10, %eax
orl %edx, %eax
incl %eax
retq
| /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
sptk::Warp(double, double, double) | double Warp(double omega, double alpha, double theta) {
if (0.0 == alpha && 0.0 == theta) return omega;
const double x(omega - theta);
const double y(omega + theta);
return (omega + std::atan2(alpha * std::sin(x), 1.0 - alpha * std::cos(x)) +
std::atan2(alpha * std::sin(y), 1.0 - alpha * std::cos(y)))... | movapd %xmm0, %xmm3
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x3d98
jp 0x3d98
ucomisd %xmm0, %xmm2
jne 0x3d98
jnp 0x3e4d
subq $0x28, %rsp
movapd %xmm3, %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
addsd %xmm3, %xmm2
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, (%rsp)
movsd %xmm3, 0x10(%rsp)
callq 0x2080
mulsd (%rsp), %x... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<sptk::uint24_t>(sptk::uint24_t*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x454c
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x454c
movq %rdi, %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x22a0
cmpq $0x3, 0x8(%rbx)
jne 0x454c
movq (%rbx), %rax
movq -0x18(%rax), %ra... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<unsigned int>(unsigned int*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x4598
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x4598
movq %rdi, %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x22a0
cmpq $0x4, 0x8(%rbx)
jne 0x4598
movq (%rbx), %rax
movq -0x18(%rax), %ra... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<float>(float*, std::istream*) | bool ReadStream(T* data_to_read, std::istream* input_stream) {
if (NULL == data_to_read || NULL == input_stream || input_stream->eof()) {
return false;
}
const int type_byte(sizeof(*data_to_read));
input_stream->read(reinterpret_cast<char*>(data_to_read), type_byte);
return (type_byte == input_stream->g... | pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x4630
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rbx,%rax)
jne 0x4630
movq %rdi, %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x22a0
cmpq $0x4, 0x8(%rbx)
jne 0x4630
movq (%rbx), %rax
movq -0x18(%rax), %ra... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<signed char>(bool, int, int, int, std::vector<signed char, std::allocator<signed char>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r12d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x47bf
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<short>(bool, int, int, int, std::vector<short, std::allocator<short>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x491f
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<int>(bool, int, int, int, std::vector<int, std::allocator<int>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x4c03
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<long>(bool, int, int, int, std::vector<long, std::allocator<long>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x4d6b
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<unsigned short>(bool, int, int, int, std::vector<unsigned short, std::allocator<unsigned short>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x5001
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::WriteStream<signed char>(int, int, std::vector<signed char, std::allocator<signed char>> const&, std::ostream*, int*) | bool WriteStream(int write_point, int write_size,
const std::vector<T>& sequence_to_write,
std::ostream* output_stream, int* actual_write_size) {
if (write_point < 0 || write_size <= 0 || NULL == output_stream) {
return false;
}
const int end(write_point + write_size);
if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testl %edi, %edi
sets %al
testl %esi, %esi
setle %cl
orb %al, %cl
testq %rbx, %rbx
sete %al
orb %cl, %al
je 0x5c10
xorl %r12d, %r12d
jmp 0x5c7a
movq %rdx, %rbp
movl %esi, %r15d
movl %edi, %r13d
leal (%r15,%r13), %ecx
movq (%rdx... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
main | ATF_TP_ADD_TCS(tp)
{
ATF_TP_ADD_TC(tp, timerfd__many_timers);
ATF_TP_ADD_TC(tp, timerfd__simple_timer);
ATF_TP_ADD_TC(tp, timerfd__simple_periodic_timer);
ATF_TP_ADD_TC(tp, timerfd__complex_periodic_timer);
ATF_TP_ADD_TC(tp, timerfd__reset_periodic_timer);
ATF_TP_ADD_TC(tp, timerfd__reenable_periodic_timer);
ATF... | leaq 0x5(%rip), %rdx # 0x22b8
jmp 0x2120
| /jiixyj[P]epoll-shim/test/timerfd-test.c |
wait_for_timerfd | static uint64_t
wait_for_timerfd(int timerfd)
{
struct pollfd pfd = { .fd = timerfd, .events = POLLIN };
ATF_REQUIRE(poll(&pfd, 1, -1) == 1);
uint64_t timeouts;
ssize_t r = read(timerfd, &timeouts, sizeof(timeouts));
ATF_REQUIRE_MSG(r == (ssize_t)sizeof(timeouts), "%d %d", (int)r, errno);
ATF_REQUIRE(timeouts ... | pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0x8(%rsp), %rdi
movl %ebx, (%rdi)
movl $0x1, 0x4(%rdi)
pushq $0x1
popq %rsi
pushq $-0x1
popq %rdx
callq 0x2140
cmpl $0x1, %eax
jne 0x2a8f
movq %rsp, %rsi
pushq $0x8
popq %rdx
movl %ebx, %edi
callq 0x20d0
cmpq $0x8, %rax
jne 0x2aa8
movq (%rsp), %rax
testq %rax, %rax
je 0x... | /jiixyj[P]epoll-shim/test/timerfd-test.c |
(anonymous namespace)::TestNotifiesReporterOfCheckFailureWithCorrectInfo::RunImpl() const | TEST(RecordsNumbersOfTests)
{
TestResults results;
results.OnTestStart(details);
results.OnTestStart(details);
results.OnTestStart(details);
CHECK_EQUAL(3, results.GetTotalTestCount());
} | pushq %rbx
subq $0x870, %rsp # imm = 0x870
leaq 0x28d33(%rip), %rax # 0x50810
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
xorl %eax, %eax
movl %eax, 0x8(%rsi)
movl %eax, 0x20c(%rsi)
movl %eax, 0x310(%rsi)
movl %eax, 0x614(%rsi)
movb %al, 0xc(%rsi)
movb %al, 0x10c(%rsi)
movb %al, 0x210(%rsi)
movb %al, 0x314(%... | /marlowa[P]quickfix/UnitTest++/src/tests/TestTestResults.cpp |
(anonymous namespace)::TestNotifiesReporterOfTestEnd::~TestNotifiesReporterOfTestEnd() | TEST(NotifiesReporterOfTestEnd)
{
RecordingReporter reporter;
TestResults results(&reporter);
results.OnTestFinish(details, 0.1234f);
CHECK_EQUAL (1, reporter.testFinishedCount);
CHECK_EQUAL ("testname", reporter.lastFinishedTest);
CHECK_EQUAL ("suitename", reporter.lastFinishedSuite);
... | pushq %rbx
movq %rdi, %rbx
callq 0x349fc
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf1d0
nop
| /marlowa[P]quickfix/UnitTest++/src/tests/TestTestResults.cpp |
(anonymous namespace)::TestTestRunnerFixtureSlowTestHasCorrectFailureInformation::~TestTestRunnerFixtureSlowTestHasCorrectFailureInformation() | TEST_FIXTURE(TestRunnerFixture, SlowTestHasCorrectFailureInformation)
{
SlowTest test;
list.Add(&test);
runner.RunTestsIf(list, NULL, True(), 3);
using namespace std;
CHECK_EQUAL(test.m_details.testName, reporter.lastFailedTest);
CHECK(strstr(test.m_details.filename, reporter.lastFailedFi... | pushq %rbx
movq %rdi, %rbx
callq 0x349fc
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf1d0
nop
| /marlowa[P]quickfix/UnitTest++/src/tests/TestTestRunner.cpp |
(anonymous namespace)::TestXmlTestReporterFixtureFailureMessageIsXMLEscaped::~TestXmlTestReporterFixtureFailureMessageIsXMLEscaped() | TEST_FIXTURE(XmlTestReporterFixture, FailureMessageIsXMLEscaped)
{
TestDetails const details("TestName", "suite", "filename.h", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "\"\'&<>");
reporter.ReportTestFinish(details, 0.1f);
reporter.ReportSummary(1, 1, 1, 0.1f... | pushq %rbx
movq %rdi, %rbx
callq 0x349fc
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf1d0
nop
| /marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
(anonymous namespace)::TestXmlTestReporterFixtureFailureMessageIsXMLEscaped::RunImpl() const | TEST_FIXTURE(XmlTestReporterFixture, FailureMessageIsXMLEscaped)
{
TestDetails const details("TestName", "suite", "filename.h", 4321);
reporter.ReportTestStart(details);
reporter.ReportFailure(details, "\"\'&<>");
reporter.ReportTestFinish(details, 0.1f);
reporter.ReportSummary(1, 1, 1, 0.1f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rsp, %rdi
callq 0x3125c
movq %rsp, %rdi
movq %rbx, 0x1a0(%rdi)
movq %rbx, %rsi
callq 0x32ba9
leaq 0x178(%rsp), %rbx
leaq 0x20267(%rip), %rax # 0x52c18
addq $0x10, %... | /marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
void UnitTest::ExecuteTest<(anonymous namespace)::XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper>((anonymous namespace)::XmlTestReporterFixtureFailureMessageIsXMLEscapedHelper&, UnitTest::TestDetails const&) | void ExecuteTest(T& testObject, TestDetails const& details)
{
CurrentTest::Details() = &details;
try
{
#ifdef UNITTEST_POSIX
UNITTEST_THROW_SIGNALS
#endif
testObject.RunImpl();
}
catch (AssertException const& e)
{
CurrentTest::Results()->OnTestFailure(
TestDetails(details.testName, details.suiteName, e.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4c8, %rsp # imm = 0x4C8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x33d60
movq %rbx, (%rax)
leaq 0x68(%rsp), %rdi
callq 0x35900
leaq 0x23497(%rip), %rax # 0x56070
movq (%rax), %rdi
movl $0x1, %esi
callq 0xf280
testl %eax, %eax
jne 0x32... | /marlowa[P]quickfix/UnitTest++/src/tests/../ExecuteTest.h |
(anonymous namespace)::TestXmlTestReporterFixtureOneFailureAndOneSuccess::~TestXmlTestReporterFixtureOneFailureAndOneSuccess() | TEST_FIXTURE(XmlTestReporterFixture, OneFailureAndOneSuccess)
{
TestDetails const failedDetails("FailedTest", "suite", "fail.h", 1);
reporter.ReportTestStart(failedDetails);
reporter.ReportFailure(failedDetails, "expected 1 but was 2");
reporter.ReportTestFinish(failedDetails, 0.1f);
TestDet... | pushq %rbx
movq %rdi, %rbx
callq 0x349fc
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf1d0
nop
| /marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
(anonymous namespace)::TestXmlTestReporterFixtureOneFailureAndOneSuccess::RunImpl() const | TEST_FIXTURE(XmlTestReporterFixture, OneFailureAndOneSuccess)
{
TestDetails const failedDetails("FailedTest", "suite", "fail.h", 1);
reporter.ReportTestStart(failedDetails);
reporter.ReportFailure(failedDetails, "expected 1 but was 2");
reporter.ReportTestFinish(failedDetails, 0.1f);
TestDet... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rsp, %rdi
callq 0x3125c
movq %rsp, %rdi
movq %rbx, 0x1a0(%rdi)
movq %rbx, %rsi
callq 0x33157
leaq 0x178(%rsp), %rbx
leaq 0x1fcb9(%rip), %rax # 0x52c18
addq $0x10, %... | /marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
void UnitTest::ExecuteTest<(anonymous namespace)::XmlTestReporterFixtureOneFailureAndOneSuccessHelper>((anonymous namespace)::XmlTestReporterFixtureOneFailureAndOneSuccessHelper&, UnitTest::TestDetails const&) | void ExecuteTest(T& testObject, TestDetails const& details)
{
CurrentTest::Details() = &details;
try
{
#ifdef UNITTEST_POSIX
UNITTEST_THROW_SIGNALS
#endif
testObject.RunImpl();
}
catch (AssertException const& e)
{
CurrentTest::Results()->OnTestFailure(
TestDetails(details.testName, details.suiteName, e.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4e8, %rsp # imm = 0x4E8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x33d60
movq %rbx, (%rax)
leaq 0x88(%rsp), %rdi
callq 0x35900
leaq 0x22ee6(%rip), %rax # 0x56070
movq (%rax), %rdi
movl $0x1, %esi
callq 0xf280
testl %eax, %eax
jne 0x33... | /marlowa[P]quickfix/UnitTest++/src/tests/../ExecuteTest.h |
(anonymous namespace)::TestXmlTestReporterFixtureMultipleFailures::~TestXmlTestReporterFixtureMultipleFailures() | TEST_FIXTURE(XmlTestReporterFixture, MultipleFailures)
{
TestDetails const failedDetails1("FailedTest", "suite", "fail.h", 1);
TestDetails const failedDetails2("FailedTest", "suite", "fail.h", 31);
reporter.ReportTestStart(failedDetails1);
reporter.ReportFailure(failedDetails1, "expected 1 but wa... | pushq %rbx
movq %rdi, %rbx
callq 0x349fc
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf1d0
nop
| /marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
(anonymous namespace)::TestXmlTestReporterFixtureMultipleFailures::RunImpl() const | TEST_FIXTURE(XmlTestReporterFixture, MultipleFailures)
{
TestDetails const failedDetails1("FailedTest", "suite", "fail.h", 1);
TestDetails const failedDetails2("FailedTest", "suite", "fail.h", 31);
reporter.ReportTestStart(failedDetails1);
reporter.ReportFailure(failedDetails1, "expected 1 but wa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rsp, %rdi
callq 0x3125c
movq %rsp, %rdi
movq %rbx, 0x1a0(%rdi)
movq %rbx, %rsi
callq 0x33771
leaq 0x178(%rsp), %rbx
leaq 0x1f69f(%rip), %rax # 0x52c18
addq $0x10, %... | /marlowa[P]quickfix/UnitTest++/src/tests/TestXmlTestReporter.cpp |
void UnitTest::ExecuteTest<(anonymous namespace)::XmlTestReporterFixtureMultipleFailuresHelper>((anonymous namespace)::XmlTestReporterFixtureMultipleFailuresHelper&, UnitTest::TestDetails const&) | void ExecuteTest(T& testObject, TestDetails const& details)
{
CurrentTest::Details() = &details;
try
{
#ifdef UNITTEST_POSIX
UNITTEST_THROW_SIGNALS
#endif
testObject.RunImpl();
}
catch (AssertException const& e)
{
CurrentTest::Results()->OnTestFailure(
TestDetails(details.testName, details.suiteName, e.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4e8, %rsp # imm = 0x4E8
movq %rsi, %rbx
movq %rdi, %r14
callq 0x33d60
movq %rbx, (%rax)
leaq 0x88(%rsp), %rdi
callq 0x35900
leaq 0x228cc(%rip), %rax # 0x56070
movq (%rax), %rdi
movl $0x1, %esi
callq 0xf280
testl %eax, %eax
jne 0x33... | /marlowa[P]quickfix/UnitTest++/src/tests/../ExecuteTest.h |
UnitTest::(anonymous namespace)::CheckStringsEqual(UnitTest::TestResults&, char const*, char const*, UnitTest::TestDetails const&) | void CheckStringsEqual(TestResults& results, char const* expected, char const* actual,
TestDetails const& details)
{
using namespace std;
if (strcmp(expected, actual))
{
UnitTest::MemoryOutStream stream;
stream << "Expected " << expected << " but was " << actual;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xf260
testl %eax, %eax
je 0x33d0c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x138f6
leaq 0x258a(%rip), %rsi # 0x3... | /marlowa[P]quickfix/UnitTest++/src/Checks.cpp |
UnitTest::DeferredTestReporter::ReportFailure(UnitTest::TestDetails const&, char const*) | void DeferredTestReporter::ReportFailure(TestDetails const& details, char const* failure)
{
DeferredTestResult& r = m_results.back();
r.failed = true;
r.failures.push_back(DeferredTestResult::Failure(details.lineNumber, failure));
r.failureFile = details.filename;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq 0x10(%rdi), %rbx
movb $0x1, -0x4(%rbx)
leaq -0x20(%rbx), %r15
movl 0x18(%rsi), %eax
leaq 0x10(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x7(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x33e88
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x34446
lea... | /marlowa[P]quickfix/UnitTest++/src/DeferredTestReporter.cpp |
UnitTest::DeferredTestResult::DeferredTestResult() | DeferredTestResult::DeferredTestResult()
: suiteName("")
, testName("")
, failureFile("")
, timeElapsed(0.0f)
, failed(false)
{
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0xb45c(%rip), %r14 # 0x3fb5e
movq %r14, %rsi
movq %r14, %rdx
callq 0x22476
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x22... | /marlowa[P]quickfix/UnitTest++/src/DeferredTestResult.cpp |
UnitTest::DeferredTestResult::DeferredTestResult(char const*, char const*) | DeferredTestResult::DeferredTestResult(char const* suite, char const* test)
: suiteName(suite)
, testName(test)
, failureFile("")
, timeElapsed(0.0f)
, failed(false)
{
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x7(%rsp), %rdx
callq 0x33e88
leaq 0x20(%rbx), %rdi
leaq 0x6(%rsp), %rdx
movq %r14, %rsi
callq 0x33e88
leaq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
leaq 0xb396(%rip), %rdx # 0x3fb5e
movq %rdx, %rsi
callq 0x22476
xorps %xmm0,... | /marlowa[P]quickfix/UnitTest++/src/DeferredTestResult.cpp |
UnitTest::DeferredTestResult::~DeferredTestResult() | DeferredTestResult::~DeferredTestResult()
{
} | pushq %rbx
movq %rdi, %rbx
addq $0x60, %rdi
callq 0x3487a
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x34847
movq (%rax), %rsi
incq %rsi
callq 0xf1d0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x3485f
movq (%rax), %rsi
incq %rsi
callq 0xf1d0
movq (%rbx), %rdi
addq $0x10, %rbx
cmp... | /marlowa[P]quickfix/UnitTest++/src/DeferredTestResult.cpp |
UnitTest::SignalTranslator::~SignalTranslator() | SignalTranslator::~SignalTranslator()
{
sigaction( SIGILL , &m_old_SIGBUS_action , 0 );
sigaction( SIGBUS , &m_old_SIGBUS_action , 0 );
sigaction( SIGTRAP, &m_old_SIGTRAP_action, 0 );
sigaction( SIGFPE , &m_old_SIGFPE_action , 0 );
sigaction( SIGSEGV, &m_old_SIGSEGV_action, 0 );
s_jumpTarget = ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x298(%rdi), %r14
movl $0x4, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xf230
movl $0x7, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xf230
leaq 0x168(%rbx), %rsi
movl $0x5, %edi
xorl %edx, %edx
callq 0xf230
leaq 0xd0(%rbx), %rsi
movl $0x8, %edi
xorl %edx, %edx
call... | /marlowa[P]quickfix/UnitTest++/src/Posix/SignalTranslator.cpp |
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.