name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
pnga_sprs_array_destroy | logical pnga_sprs_array_destroy(Integer s_a)
{
Integer hdl = GA_OFFSET + s_a;
Integer ret = 1;
int local_sync_begin,local_sync_end;
local_sync_begin = _ga_sync_begin; local_sync_end = _ga_sync_end;
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous masking*/
if (local_sync_begin) pnga_pgroup_sync(SPA[hdl].grp);
if (SPA[hdl].ready) {
if (!pnga_destroy(SPA[hdl].g_data)) ret = 0;
if (!pnga_destroy(SPA[hdl].g_i)) ret = 0;
if (!pnga_destroy(SPA[hdl].g_j)) ret = 0;
if (!pnga_destroy(SPA[hdl].g_blk)) ret = 0;
if (SPA[hdl].blkidx != NULL) {
free(SPA[hdl].blkidx);
SPA[hdl].blkidx = NULL;
}
if (SPA[hdl].blksize != NULL) {
free(SPA[hdl].blksize);
SPA[hdl].blksize = NULL;
}
if (SPA[hdl].offset != NULL) {
free(SPA[hdl].offset);
SPA[hdl].offset = NULL;
}
} else if (SPA[hdl].active) {
free(SPA[hdl].val);
SPA[hdl].val = NULL;
free(SPA[hdl].idx);
SPA[hdl].idx = NULL;
free(SPA[hdl].jdx);
SPA[hdl].jdx = NULL;
}
SPA[hdl].active = 0;
SPA[hdl].ready = 0;
if (local_sync_end) pnga_pgroup_sync(SPA[hdl].grp);
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x3e8, %rbx # imm = 0x3E8
leaq 0x99660(%rip), %rax # 0xd7160
leaq 0x9965d(%rip), %rcx # 0xd7164
cmpl $0x0, (%rax)
movl (%rcx), %ebp
movl $0x1, %edx
movl %edx, (%rax)
movl %edx, (%rcx)
je 0x3db32
leaq 0x9e5a2(%rip), %rax # 0xdc0c0
movq (%rax), %rax
imulq $0xc8, %rbx, %rcx
movq 0x38(%rax,%rcx), %rdi
callq 0x6979c
leaq 0x9e587(%rip), %r14 # 0xdc0c0
movq (%r14), %rcx
imulq $0xc8, %rbx, %rbx
leaq (%rcx,%rbx), %rax
cmpq $0x0, 0xc0(%rcx,%rbx)
je 0x3dc0d
movl %ebp, 0x4(%rsp)
movq 0x10(%rax), %rdi
callq 0x63281
testq %rax, %rax
setne %r12b
movq (%r14), %rax
movq 0x20(%rax,%rbx), %rdi
callq 0x63281
testq %rax, %rax
setne %r13b
movq (%r14), %rax
movq 0x18(%rax,%rbx), %rdi
callq 0x63281
testq %rax, %rax
setne %bpl
movq (%r14), %rax
movq 0x28(%rax,%rbx), %rdi
callq 0x63281
testq %rax, %rax
setne %r15b
andb %bpl, %r15b
movq (%r14), %rax
movq 0x60(%rax,%rbx), %rdi
testq %rdi, %rdi
je 0x3dbc7
callq 0x3330
movq (%r14), %rax
movq $0x0, 0x60(%rax,%rbx)
andb %r13b, %r15b
movq (%r14), %rax
movq 0x68(%rax,%rbx), %rdi
testq %rdi, %rdi
je 0x3dbe8
callq 0x3330
movq (%r14), %rax
movq $0x0, 0x68(%rax,%rbx)
andb %r12b, %r15b
movq (%r14), %rax
movq 0x70(%rax,%rbx), %rdi
testq %rdi, %rdi
movl 0x4(%rsp), %ebp
je 0x3dc76
callq 0x3330
movq (%r14), %rax
addq %rbx, %rax
addq $0x70, %rax
jmp 0x3dc6f
cmpq $0x0, 0xb8(%rax)
je 0x3dca5
movq 0x90(%rax), %rdi
callq 0x3330
movq (%r14), %rax
xorl %r15d, %r15d
movq %r15, 0x90(%rax,%rbx)
movq (%r14), %rax
movq 0x80(%rax,%rbx), %rdi
callq 0x3330
movq (%r14), %rax
movq %r15, 0x80(%rax,%rbx)
movq (%r14), %rax
movq 0x88(%rax,%rbx), %rdi
callq 0x3330
movq (%r14), %rax
addq %rbx, %rax
addq $0x88, %rax
movb $0x1, %r15b
movq $0x0, (%rax)
movq (%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xb8(%rax,%rbx)
testl %ebp, %ebp
je 0x3dc92
movq 0x38(%rax,%rbx), %rdi
callq 0x6979c
movzbl %r15b, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0x3dc76
| /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_get_diag | void pnga_sprs_array_get_diag(Integer s_a, Integer *g_d)
{
Integer hdl = GA_OFFSET + s_a;
int local_sync_begin,local_sync_end;
Integer *map;
Integer grp = SPA[hdl].grp;
Integer me = pnga_pgroup_nodeid(grp);
Integer nproc = pnga_pgroup_nnodes(grp);
Integer iproc;
Integer one = 1;
Integer lo, hi;
Integer ilo, ihi, jlo, jhi, ncols;
int *iptr, *jptr;
int64_t *ilptr, *jlptr;
int idx_size = SPA[hdl].idx_size;
Integer i, j;
void *diag, *vptr;
char op[2];
local_sync_begin = _ga_sync_begin; local_sync_end = _ga_sync_end;
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous masking*/
if (local_sync_begin) pnga_pgroup_sync(grp);
/* Get row distribution of matrix */
map = (Integer*)malloc((nproc+1)*sizeof(Integer));
for (iproc=0; iproc<nproc+1; iproc++) map[iproc] = 0;
map[me] = SPA[hdl].ilo+1;
if (me == nproc-1) map[me+1] = SPA[hdl].ihi+1;
op[0] = '+';
op[1] = '\0';
if (sizeof(Integer) == 4) {
pnga_pgroup_gop(grp, C_INT, map, nproc+1, op);
} else {
pnga_pgroup_gop(grp, C_LONG, map, nproc+1, op);
}
/* Create array to hold diagonal */
*g_d = pnga_create_handle();
pnga_set_data(*g_d,one,&SPA[hdl].idim,SPA[hdl].type);
pnga_set_pgroup(*g_d,SPA[hdl].grp);
pnga_set_irreg_distr(*g_d,map,&nproc);
pnga_allocate(*g_d);
/* zero all elements. If diagonal element is not found for a row, then it
* must be zero */
pnga_zero(*g_d);
pnga_distribution(*g_d,me,&lo,&hi);
pnga_access_ptr(*g_d, &lo, &hi, &diag, &one);
/* extract diagonal elements */
pnga_sprs_array_row_distribution(s_a,me,&ilo,&ihi);
pnga_sprs_array_column_distribution(s_a,me,&jlo,&jhi);
if (idx_size == 4) {
pnga_sprs_array_access_col_block(s_a,me,&iptr,&jptr,&vptr);
for (i=ilo; i<=ihi; i++) {
ncols = iptr[i+1-ilo]-iptr[i-ilo];
for (j=0; j<ncols; j++) {
if (i == jptr[iptr[i-ilo]+j]) {
if (SPA[hdl].type == C_INT) {
((int*)diag)[i-ilo] = ((int*)vptr)[iptr[i-ilo]+j];
} else if (SPA[hdl].type == C_LONG) {
((long*)diag)[i-ilo] = ((long*)vptr)[iptr[i-ilo]+j];
} else if (SPA[hdl].type == C_LONGLONG) {
((long long*)diag)[i-ilo] = ((long long*)vptr)[iptr[i-ilo]+j];
} else if (SPA[hdl].type == C_FLOAT) {
((float*)diag)[i-ilo] = ((float*)vptr)[iptr[i-ilo]+j];
} else if (SPA[hdl].type == C_DBL) {
((double*)diag)[i-ilo] = ((double*)vptr)[iptr[i-ilo]+j];
} else if (SPA[hdl].type == C_SCPL) {
((SingleComplex*)diag)[i-ilo] = ((SingleComplex*)vptr)[iptr[i-ilo]+j];
} else if (SPA[hdl].type == C_DCPL) {
((DoubleComplex*)diag)[i-ilo] = ((DoubleComplex*)vptr)[iptr[i-ilo]+j];
}
}
}
}
} else {
pnga_sprs_array_access_col_block(s_a,me,&ilptr,&jlptr,&vptr);
for (i=ilo; i<=ihi; i++) {
ncols = ilptr[i+1-ilo]-ilptr[i-ilo];
for (j=0; j<ncols; j++) {
if (i == jlptr[ilptr[i-ilo]+j]) {
if (SPA[hdl].type == C_INT) {
((int*)diag)[i-ilo] = ((int*)vptr)[ilptr[i-ilo]+j];
} else if (SPA[hdl].type == C_LONG) {
((long*)diag)[i-ilo] = ((long*)vptr)[ilptr[i-ilo]+j];
} else if (SPA[hdl].type == C_LONGLONG) {
((long long*)diag)[i-ilo] = ((long long*)vptr)[ilptr[i-ilo]+j];
} else if (SPA[hdl].type == C_FLOAT) {
((float*)diag)[i-ilo] = ((float*)vptr)[ilptr[i-ilo]+j];
} else if (SPA[hdl].type == C_DBL) {
((double*)diag)[i-ilo] = ((double*)vptr)[ilptr[i-ilo]+j];
} else if (SPA[hdl].type == C_SCPL) {
((SingleComplex*)diag)[i-ilo] = ((SingleComplex*)vptr)[ilptr[i-ilo]+j];
} else if (SPA[hdl].type == C_DCPL) {
((DoubleComplex*)diag)[i-ilo] = ((DoubleComplex*)vptr)[ilptr[i-ilo]+j];
}
}
}
}
}
free(map);
pnga_release_update(*g_d, &lo, &hi);
if (local_sync_end) pnga_pgroup_sync(grp);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, 0x48(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x3e8(%rdi), %rax
leaq 0x9d8b9(%rip), %r14 # 0xdc0c0
movq (%r14), %rcx
imulq $0xc8, %rax, %r12
movq 0x38(%rcx,%r12), %r15
movq %r15, %rdi
callq 0x62fe1
movq %rax, %r13
movq %r15, %rdi
callq 0x63c46
movq %rax, 0x68(%rsp)
movq $0x1, 0x60(%rsp)
movq (%r14), %rax
movl 0x30(%rax,%r12), %eax
movq %rax, 0x18(%rsp)
leaq 0x98915(%rip), %rax # 0xd7160
leaq 0x98912(%rip), %rcx # 0xd7164
cmpl $0x0, (%rax)
movl (%rcx), %edx
movl %edx, 0x38(%rsp)
movl $0x1, %edx
movl %edx, (%rax)
movl %edx, (%rcx)
je 0x3e86e
movq %r15, %rdi
callq 0x6979c
movq 0x68(%rsp), %rbp
leaq 0x8(,%rbp,8), %rbx
movq %rbx, %rdi
callq 0x33b0
testq %rbp, %rbp
movq %rax, 0x40(%rsp)
js 0x3e89f
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3170
movq 0x40(%rsp), %rax
movq (%r14), %rdx
movq 0x40(%rdx,%r12), %rcx
incq %rcx
movq %rcx, (%rax,%r13,8)
leaq -0x1(%rbp), %rcx
cmpq %rcx, %r13
jne 0x3e8c4
movq 0x48(%rdx,%r12), %rcx
incq %rcx
movq %rcx, 0x8(%rax,%r13,8)
leaq 0x3e(%rsp), %r8
movw $0x2b, (%r8)
incq %rbp
movl $0x3ea, %esi # imm = 0x3EA
movq %r15, 0x70(%rsp)
movq %r15, %rdi
movq %rax, %rbx
movq %rax, %rdx
movq %rbp, %rcx
callq 0x7807b
xorl %eax, %eax
callq 0x6029f
movq 0x48(%rsp), %rbp
movq %rax, (%rbp)
leaq 0x60(%rsp), %rcx
movq (%rcx), %rsi
movq (%r14), %rdx
movq 0xa8(%rdx,%r12), %rcx
addq %r12, %rdx
movq %rax, %rdi
callq 0x603b3
movq (%rbp), %rdi
movq (%r14), %rax
movq 0x38(%rax,%r12), %rsi
callq 0x60691
movq (%rbp), %rdi
leaq 0x68(%rsp), %rdx
movq %rbx, %rsi
callq 0x6086c
movq (%rbp), %rdi
callq 0x61ef0
movq (%rbp), %rdi
callq 0x10708
movq (%rbp), %rdi
leaq 0x80(%rsp), %rbx
leaq 0x78(%rsp), %r15
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x5f51f
movq (%rbp), %rdi
leaq 0x8(%rsp), %rcx
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %r8
callq 0x6b58f
leaq 0x58(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3c2ab
leaq 0x90(%rsp), %rdx
leaq 0x88(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3c3f8
cmpl $0x4, 0x18(%rsp)
jne 0x3eaf7
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3c572
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
cmpq %rcx, %rax
jg 0x3ec21
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq $-0x3e9, %r8 # imm = 0xFC17
leaq 0x76f69(%rip), %r9 # 0xb5984
movq 0x10(%rsp), %r10
movq %r10, %r11
incq %r10
movq %r10, %rax
movq 0x10(%rsp), %r15
subq %r15, %rax
movl (%rdx,%rax,4), %ecx
movq %r11, %rbx
subq %r15, %rbx
subl (%rdx,%rbx,4), %ecx
jle 0x3eae7
movl %ecx, %r15d
movq %rbx, %r13
shlq $0x4, %r13
xorl %ebp, %ebp
movslq (%rdx,%rbx,4), %rcx
addq %rbp, %rcx
movslq (%rsi,%rcx,4), %rax
cmpq %rax, %r11
jne 0x3eadb
movq (%r14), %rax
movq 0xa8(%rax,%r12), %rax
addq %r8, %rax
cmpq $0xf, %rax
ja 0x3eadb
movslq (%r9,%rax,4), %rax
addq %r9, %rax
jmpq *%rax
movq (%rdi,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
jmp 0x3eadb
movss (%rdi,%rcx,4), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax,%rbx,4)
jmp 0x3eadb
movl (%rdi,%rcx,4), %eax
movq 0x8(%rsp), %rcx
movl %eax, (%rcx,%rbx,4)
jmp 0x3eadb
movsd (%rdi,%rcx,8), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax,%rbx,8)
jmp 0x3eadb
movq 0x8(%rsp), %rax
movq (%rdi,%rcx,8), %rcx
movq %rcx, (%rax,%rbx,8)
jmp 0x3eadb
movq 0x8(%rsp), %rax
shlq $0x4, %rcx
movups (%rdi,%rcx), %xmm0
movups %xmm0, (%rax,%r13)
incq %rbp
cmpq %rbp, %r15
jne 0x3ea4f
cmpq 0x18(%rsp), %r11
jne 0x3ea20
jmp 0x3ec21
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3c572
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
cmpq %rcx, %rax
jg 0x3ec21
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq $-0x3e9, %r8 # imm = 0xFC17
leaq 0x76df9(%rip), %r9 # 0xb5944
movq 0x10(%rsp), %r10
movq %r10, %r11
incq %r10
movq %r10, %rax
movq 0x10(%rsp), %rcx
subq %rcx, %rax
movq (%rdx,%rax,8), %rbx
movq %r11, %r15
subq %rcx, %r15
subq (%rdx,%r15,8), %rbx
jle 0x3ec16
movq %r15, %r13
shlq $0x4, %r13
xorl %ebp, %ebp
movq (%rdx,%r15,8), %rcx
addq %rbp, %rcx
cmpq (%rsi,%rcx,8), %r11
jne 0x3ec0a
movq (%r14), %rax
movq 0xa8(%rax,%r12), %rax
addq %r8, %rax
cmpq $0xf, %rax
ja 0x3ec0a
movslq (%r9,%rax,4), %rax
addq %r9, %rax
jmpq *%rax
movq (%rdi,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
jmp 0x3ec0a
movss (%rdi,%rcx,4), %xmm0
movq 0x8(%rsp), %rax
movss %xmm0, (%rax,%r15,4)
jmp 0x3ec0a
movl (%rdi,%rcx,4), %eax
movq 0x8(%rsp), %rcx
movl %eax, (%rcx,%r15,4)
jmp 0x3ec0a
movsd (%rdi,%rcx,8), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax,%r15,8)
jmp 0x3ec0a
movq 0x8(%rsp), %rax
movq (%rdi,%rcx,8), %rcx
movq %rcx, (%rax,%r15,8)
jmp 0x3ec0a
movq 0x8(%rsp), %rax
shlq $0x4, %rcx
movups (%rdi,%rcx), %xmm0
movups %xmm0, (%rax,%r13)
incq %rbp
cmpq %rbp, %rbx
jne 0x3eb7e
cmpq 0x18(%rsp), %r11
jne 0x3eb50
movq 0x40(%rsp), %rdi
callq 0x3330
movq 0x48(%rsp), %rax
movq (%rax), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x6dcc9
cmpl $0x0, 0x38(%rsp)
movq 0x70(%rsp), %rdi
je 0x3ec56
callq 0x6979c
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/sparse.array.c |
pnga_sprs_array_sprsdns_multiply | Integer pnga_sprs_array_sprsdns_multiply(Integer s_a, Integer g_b, Integer trans)
{
Integer lcnt;
Integer icnt;
Integer hdl_a = s_a+GA_OFFSET;
Integer hdl_b = g_b+GA_OFFSET;
Integer hdl_c;
int local_sync_begin,local_sync_end;
Integer elemsize;
Integer idim, jdim;
Integer i, j, k, l, m, n, nn;
Integer nprocs = pnga_pgroup_nnodes(SPA[hdl_a].grp);
Integer me = pnga_pgroup_nodeid(SPA[hdl_a].grp);
Integer longidx;
Integer type;
Integer jhi, jlo;
Integer gdims[2], blocks[2];
Integer rowdim;
Integer *count;
Integer nblocks;
Integer g_c;
Integer two = 2;
Integer ilen;
Integer max_nnz_a, max_nnz_b;
Integer *row_nnz;
int64_t max_nnz;
Integer *map, *size;
local_sync_begin = _ga_sync_begin; local_sync_end = _ga_sync_end;
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous masking*/
if (local_sync_begin) pnga_pgroup_sync(SPA[hdl_a].grp);
/* Do some initial verification to see if matrix multiply is possible */
if (SPA[hdl_a].type != GA[hdl_b].type) {
pnga_error("(ga_sprs_array_sprsdns_multiply) types of sparse matrices"
" A and B must match",0);
}
type = SPA[hdl_a].type;
if (SPA[hdl_a].grp != GA[hdl_b].p_handle) {
pnga_error("(ga_sprs_array_sprsdns_multiply) matrices A and B must"
" be on the same group",0);
}
if (GA[hdl_b].ndim != 2) {
pnga_error("(ga_sprs_array_sprsdns_multiply) matrix B must be"
" of dimension 2",GA[hdl_b].ndim);
}
if ((trans && SPA[hdl_a].jdim != GA[hdl_b].dims[1]) ||
(!trans && SPA[hdl_a].jdim != GA[hdl_b].dims[0])) {
pnga_error("(ga_sprs_array_sprsdns_multiply) column dimension of"
" A must match row dimension of B",0);
}
if (SPA[hdl_a].idx_size == sizeof(int64_t)) {
longidx = 1;
} else {
longidx = 0;
}
elemsize = SPA[hdl_a].size;
idim = SPA[hdl_a].idim;
if (trans) {
jdim = GA[hdl_b].dims[0];
} else {
jdim = GA[hdl_b].dims[1];
}
/* Construct product array C*/
pnga_mask_sync(local_sync_begin,local_sync_end);
g_c = pnga_create_handle();
hdl_c = g_c + GA_OFFSET;
if (trans) {
gdims[0] = jdim;
gdims[1] = idim;
} else {
gdims[0] = idim;
gdims[1] = jdim;
}
pnga_set_data(g_c,two,gdims,type);
map = (Integer*)malloc((nprocs+1)*sizeof(Integer));
size = (Integer*)malloc(nprocs*sizeof(Integer));
for (i=0; i<nprocs; i++) size[i] = 0;
size[me] = SPA[hdl_a].ihi-SPA[hdl_a].ilo+1;
if (sizeof(Integer) == 8) {
pnga_pgroup_gop(SPA[hdl_a].grp,C_LONG,size,nprocs,"+");
} else {
pnga_pgroup_gop(SPA[hdl_a].grp,C_INT,size,nprocs,"+");
}
if (trans) {
map[0] = 1;
map[1] = 1;
for (i=1; i<nprocs; i++) {
map[i+1] = map[i] + size[i-1];
}
blocks[0] = 1;
blocks[1] = nprocs;
} else {
map[0] = 1;
for (i=1; i<nprocs; i++) {
map[i] = map[i-1] + size[i-1];
}
map[nprocs] = 1;
blocks[0] = nprocs;
blocks[1] = 1;
}
pnga_set_irreg_distr(g_c,map,blocks);
pnga_set_pgroup(g_c,SPA[hdl_a].grp);
pnga_mask_sync(local_sync_begin,local_sync_end);
if (!pnga_allocate(g_c)) {
pnga_error("(ga_sprs_array_sprsdns_multiply) could not allocate"
" product array C",0);
}
pnga_mask_sync(local_sync_begin,local_sync_end);
pnga_zero(g_c);
/* loop over processors in row to get target block and then loop over
* processors to get all block pairs that contribute to target block.
* Multiply block pairs */
for (l=0; l<nprocs; l++) {
/* Find bounding dimensions (unit-based) of target block in row */
void *data_c;
void *data_a, *data_b;
Integer lo_c[2], hi_c[2], ld_c[2];
Integer tlo_c[2], thi_c[2];
lo_c[0] = SPA[hdl_a].ilo+1;
hi_c[0] = SPA[hdl_a].ihi+1;
pnga_sprs_array_column_distribution(s_a,l,&lo_c[1],&hi_c[1]);
lo_c[1]++;
hi_c[1]++;
/* loop over all sub-blocks in column and row block that contribute
* to target block */
if (trans) {
tlo_c[0] = lo_c[1];
thi_c[0] = hi_c[1];
tlo_c[1] = lo_c[0];
thi_c[1] = hi_c[0];
} else {
tlo_c[0] = lo_c[0];
thi_c[0] = hi_c[0];
tlo_c[1] = lo_c[1];
thi_c[1] = hi_c[1];
}
/* loop over non-zero blocks in row in sparse matrix A */
for (nn=0; nn<SPA[hdl_a].nblocks; nn++) {
void *iptr_a, *jptr_a;
Integer ilo_a, ihi_a, jlo_a, jhi_a;
Integer lo_b[2], hi_b[2], ld_b[2];
Integer tlo_b[2], thi_b[2];
void *val_a;
void *buf_b;
Integer nelem;
Integer ii,jlen;
n = SPA[hdl_a].blkidx[nn];
/* calculate values of jlo and jhi for block in g_b */
if (trans) {
ld_c[0] = jdim;
ld_c[1] = thi_c[1]-tlo_c[1]+1;
} else {
ld_c[0] = thi_c[0]-tlo_c[0]+1;
ld_c[1] = jdim;
}
pnga_access_ptr(g_c,tlo_c,thi_c,&data_c,ld_c);
/* Find block of A for multiplication */
ilo_a = lo_c[0]-1;
ihi_a = hi_c[0]-1;
pnga_sprs_array_column_distribution(s_a, n, &jlo_a, &jhi_a);
/* get pointer to sparse block */
pnga_sprs_array_access_col_block(s_a, n, &iptr_a, &jptr_a, &val_a);
lo_b[0] = jlo_a+1;
hi_b[0] = jhi_a+1;
lo_b[1] = lo_c[1];
hi_b[1] = hi_c[1];
if (trans) {
tlo_b[0] = lo_b[1];
thi_b[0] = hi_b[1];
tlo_b[1] = lo_b[0];
thi_b[1] = hi_b[0];
} else {
tlo_b[0] = lo_b[0];
thi_b[0] = hi_b[0];
tlo_b[1] = lo_b[1];
thi_b[1] = hi_b[1];
}
/* Copy block from dense array into buffer */
nelem = (thi_b[0]-tlo_b[0]+1)*(thi_b[1]-tlo_b[1]+1);
buf_b = malloc(nelem*SPA[hdl_a].size);
ld_b[0] = (thi_b[0]-tlo_b[0]+1);
ld_b[1] = (thi_b[1]-tlo_b[1]+1);
pnga_get(g_b,tlo_b,thi_b,buf_b,ld_b);
if (SPA[hdl_a].idx_size == 4) {
int *idx_a = (int*)iptr_a;
int *jdx_a = (int*)jptr_a;
data_a = val_a;
/* now have access to blocks from A, B, and C. Perform block
* multiplication */
if (type == C_INT) {
REAL_SPRSDNS_MULTIPLY_M(int,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],thi_b[0],
idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_LONG) {
REAL_SPRSDNS_MULTIPLY_M(long,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],thi_b[0],
idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_LONGLONG) {
REAL_SPRSDNS_MULTIPLY_M(long long,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],
thi_b[0],idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_FLOAT) {
REAL_SPRSDNS_MULTIPLY_M(float,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],thi_b[0],
idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_DBL) {
REAL_SPRSDNS_MULTIPLY_M(double,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],thi_b[0],
idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_SCPL) {
COMPLEX_SPRSDNS_MULTIPLY_M(float,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],
thi_b[0],idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_DCPL) {
COMPLEX_SPRSDNS_MULTIPLY_M(double,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],
thi_b[0],idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
}
} else {
int64_t *idx_a = (int64_t*)iptr_a;
int64_t *jdx_a = (int64_t*)jptr_a;
data_a = val_a;
/* now have access to blocks from A, B, and C. Perform block
* multiplication */
if (type == C_INT) {
REAL_SPRSDNS_MULTIPLY_M(int,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],thi_b[0],
idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_LONG) {
REAL_SPRSDNS_MULTIPLY_M(long,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],thi_b[0],
idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_LONGLONG) {
REAL_SPRSDNS_MULTIPLY_M(long long,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],
thi_b[0],idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_FLOAT) {
REAL_SPRSDNS_MULTIPLY_M(float,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],thi_b[0],
idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_DBL) {
REAL_SPRSDNS_MULTIPLY_M(double,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],
thi_b[0],idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_SCPL) {
COMPLEX_SPRSDNS_MULTIPLY_M(float,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],
thi_b[0],idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
} else if (type == C_DCPL) {
COMPLEX_SPRSDNS_MULTIPLY_M(double,ilo_a,ihi_a,jlo_a,jhi_a,tlo_b[0],
thi_b[0],idx_a,jdx_a,data_a,buf_b,data_c,ld_c[0]);
}
}
free(buf_b);
}
}
if (local_sync_end) pnga_pgroup_sync(SPA[hdl_a].grp);
return g_c;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %rdx, 0x30(%rsp)
movl $0x3e8, %r15d # imm = 0x3E8
movq %rdi, 0x120(%rsp)
leaq (%rdi,%r15), %rax
movq %rsi, 0x140(%rsp)
addq %rsi, %r15
leaq 0x97a57(%rip), %r13 # 0xdc0c0
movq (%r13), %rcx
imulq $0xc8, %rax, %rbp
movq 0x38(%rcx,%rbp), %rdi
callq 0x63c46
movq %rax, %r12
movq (%r13), %rax
movq 0x38(%rax,%rbp), %rdi
callq 0x62fe1
movq %rax, 0x40(%rsp)
leaq 0x92ac5(%rip), %rax # 0xd7160
movslq (%rax), %rsi
leaq 0x92abf(%rip), %rcx # 0xd7164
movslq (%rcx), %rbx
movl $0x1, %edx
movl %edx, (%rax)
movl %edx, (%rcx)
movq %rsi, 0x28(%rsp)
testq %rsi, %rsi
je 0x446c9
movq (%r13), %rax
movq 0x38(%rax,%rbp), %rdi
callq 0x6979c
movq (%r13), %rax
leaq 0x981e4(%rip), %r14 # 0xdc8b8
movq (%r14), %rcx
imulq $0x368, %r15, %r15 # imm = 0x368
movslq 0x4(%rcx,%r15), %rcx
cmpq %rcx, 0xa8(%rax,%rbp)
je 0x446fb
leaq 0x71e68(%rip), %rdi # 0xb655c
xorl %esi, %esi
callq 0x18f07
movq (%r13), %rax
movq 0xa8(%rax,%rbp), %rcx
movq %rcx, 0xb0(%rsp)
movq (%r14), %rcx
movslq 0x210(%rcx,%r15), %rcx
cmpq %rcx, 0x38(%rax,%rbp)
je 0x4472f
leaq 0x71e81(%rip), %rdi # 0xb65a9
xorl %esi, %esi
callq 0x18f07
movq (%r14), %rax
movswq (%rax,%r15), %rsi
cmpq $0x2, %rsi
je 0x44749
leaq 0x71eb1(%rip), %rdi # 0xb65f5
callq 0x18f07
movq (%r13), %rax
movq 0x8(%rax,%rbp), %rax
movq (%r14), %rcx
cmpq $0x0, 0x30(%rsp)
movq %rbx, 0xc0(%rsp)
je 0x448b3
cmpq 0x38(%rcx,%r15), %rax
je 0x4477e
leaq 0x71ebf(%rip), %rdi # 0xb6636
xorl %esi, %esi
callq 0x18f07
cmpq $0x0, 0x30(%rsp)
movq (%r13), %rax
movq (%rax,%rbp), %rbx
movq (%r14), %rax
leaq 0x30(%rax,%r15), %rcx
leaq 0x38(%rax,%r15), %rax
cmovneq %rcx, %rax
movq (%rax), %rax
movq %rax, %r14
cmoveq %rbx, %r14
movq %rax, 0x110(%rsp)
cmoveq %rax, %rbx
movq 0x28(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x68c58
xorl %eax, %eax
callq 0x6029f
movq %rax, %r15
leaq 0x1a0(%rsp), %rdx
movq %r14, (%rdx)
movq %rbx, 0x8(%rdx)
movl $0x2, %esi
movq %rax, %rdi
movq 0xb0(%rsp), %rcx
callq 0x603b3
leaq (,%r12,8), %rbx
leaq 0x8(,%r12,8), %rdi
callq 0x33b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x33b0
movq %r12, %rcx
movq %rax, %r12
movq %rcx, 0xb8(%rsp)
testq %rcx, %rcx
jle 0x44833
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3170
movq (%r13), %rax
movq 0x48(%rax,%rbp), %rcx
subq 0x40(%rax,%rbp), %rcx
incq %rcx
movq 0x40(%rsp), %rdx
movq %rcx, (%r12,%rdx,8)
movq 0x38(%rax,%rbp), %rdi
leaq 0x6dc31(%rip), %r8 # 0xb248a
movl $0x3ea, %esi # imm = 0x3EA
movq %r12, %rdx
movq 0xb8(%rsp), %rbx
movq %rbx, %rcx
callq 0x7807b
movq $0x1, (%r14)
cmpq $0x0, 0x30(%rsp)
je 0x448c3
movq $0x1, 0x8(%r14)
movl $0x1, %eax
cmpq $0x2, %rbx
jl 0x448ae
movq 0x8(%r14), %rcx
movl $0x1, %edx
addq -0x8(%r12,%rdx,8), %rcx
movq %rcx, 0x8(%r14,%rdx,8)
incq %rdx
cmpq %rdx, %rbx
jne 0x4489c
movq %rbx, %rcx
jmp 0x44902
cmpq 0x30(%rcx,%r15), %rax
jne 0x44770
jmp 0x4477e
cmpq $0x2, %rbx
jl 0x448ea
movq (%r14), %rax
movq 0xb8(%rsp), %rcx
decq %rcx
xorl %edx, %edx
addq (%r12,%rdx,8), %rax
movq %rax, 0x8(%r14,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x448d9
movq 0xb8(%rsp), %rbx
movq $0x1, (%r14,%rbx,8)
movl $0x1, %ecx
movq %rbx, %rax
leaq 0x190(%rsp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6086c
movq (%r13), %rax
movq 0x38(%rax,%rbp), %rsi
movq %r15, %rdi
callq 0x60691
movq 0x28(%rsp), %r12
movq %r12, %rdi
movq 0xc0(%rsp), %r14
movq %r14, %rsi
callq 0x68c58
movq %r15, %rdi
callq 0x61ef0
testq %rax, %rax
jne 0x44960
leaq 0x71d32(%rip), %rdi # 0xb668b
xorl %esi, %esi
callq 0x18f07
movq %r12, %rdi
movq %r14, %rsi
callq 0x68c58
movq %r15, %rdi
callq 0x10708
testq %rbx, %rbx
jle 0x460d8
xorl %ebx, %ebx
addq $-0x3e9, 0xb0(%rsp) # imm = 0xFC17
movq %rbp, 0x138(%rsp)
movq %r15, 0x130(%rsp)
movq (%r13), %rax
movq 0x40(%rax,%rbp), %rcx
incq %rcx
movq %rcx, 0x100(%rsp)
movq 0x48(%rax,%rbp), %rax
incq %rax
movq %rax, 0xf0(%rsp)
movq 0x120(%rsp), %rdi
movq %rbx, %rsi
leaq 0x108(%rsp), %rdx
leaq 0xf8(%rsp), %rcx
callq 0x3c3f8
movq 0x108(%rsp), %r14
incq %r14
movq 0xf8(%rsp), %rcx
incq %rcx
movq %r14, 0x108(%rsp)
movq %rcx, 0xf8(%rsp)
cmpq $0x0, 0x30(%rsp)
movq %rcx, 0x118(%rsp)
movq %rbx, 0x128(%rsp)
je 0x44a4e
movq %r14, 0xe0(%rsp)
movq %rcx, 0xd0(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0xd8(%rsp)
jmp 0x44a7e
movq 0x100(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq %r14, 0xe8(%rsp)
movq %rcx, 0xd8(%rsp)
movq (%r13), %rax
cmpq $0x0, 0x58(%rax,%rbp)
jle 0x460bf
movq 0x100(%rsp), %rcx
movq %rcx, 0x58(%rsp)
decq %rcx
movq %rcx, 0x10(%rsp)
movq 0xf0(%rsp), %rcx
movq %rcx, 0x18(%rsp)
xorl %ecx, %ecx
movq %r14, 0x148(%rsp)
movq 0x60(%rax,%rbp), %rax
movq (%rax,%rcx,8), %r12
cmpq $0x0, 0x30(%rsp)
movq %rcx, 0x150(%rsp)
je 0x44af8
movq 0x110(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xd8(%rsp), %rax
subq 0xe8(%rsp), %rax
incq %rax
jmp 0x44b1b
movq 0xd0(%rsp), %rax
subq 0xe0(%rsp), %rax
incq %rax
movq %rax, 0xa0(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq %r15, %rdi
leaq 0xe0(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0xa0(%rsp), %r8
callq 0x6b58f
movq 0x120(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x168(%rsp), %rdx
leaq 0x160(%rsp), %rcx
callq 0x3c3f8
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x178(%rsp), %rdx
leaq 0x170(%rsp), %rcx
leaq 0x158(%rsp), %r8
callq 0x3c572
movq 0x168(%rsp), %rcx
movq %rcx, 0x28(%rsp)
incq %rcx
movq 0x160(%rsp), %rax
incq %rax
cmpq $0x0, 0x30(%rsp)
je 0x44bd0
movq %r14, 0x80(%rsp)
movq 0x118(%rsp), %rdx
movq %rdx, 0x70(%rsp)
movq %rcx, 0x88(%rsp)
jmp 0x44bed
movq %rcx, 0x80(%rsp)
movq %rax, 0x70(%rsp)
movq %r14, 0x88(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x78(%rsp)
movdqa 0x70(%rsp), %xmm0
psubq 0x80(%rsp), %xmm0
movq (%r13), %rax
psubq 0x6fdf3(%rip), %xmm0 # 0xb4a00
movdqa %xmm0, 0x40(%rsp)
movq %xmm0, %rcx
pshufd $0xee, %xmm0, %xmm0 # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rdi
imulq %rcx, %rdi
imulq 0xb0(%rax,%rbp), %rdi
callq 0x33b0
movapd 0x40(%rsp), %xmm0
movapd %xmm0, 0x180(%rsp)
movq 0x140(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x70(%rsp), %rdx
movq %rax, 0x40(%rsp)
movq %rax, %rcx
leaq 0x180(%rsp), %r8
callq 0x6abb1
movq (%r13), %rax
cmpq $0x4, 0x30(%rax,%rbp)
movq 0x178(%rsp), %rax
movq 0x170(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq 0x158(%rsp), %rdx
jne 0x44e20
cmpq $0xf, 0xb0(%rsp)
movaps 0x6c7e6(%rip), %xmm4 # 0xb1490
movapd 0x6c7ee(%rip), %xmm5 # 0xb14a0
ja 0x4607c
movq 0xb0(%rsp), %rcx
leaq 0x70f7d(%rip), %rsi # 0xb5c44
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rdi
movq 0x80(%rsp), %rcx
movq %rdi, (%rsp)
movq %rcx, 0x20(%rsp)
subq %rcx, %rdi
incq %rdi
leaq (,%rdi,4), %r8
movq $0x0, 0x98(%rsp)
movq 0x10(%rsp), %r11
movq %r11, 0x38(%rsp)
subq 0x10(%rsp), %r11
movl 0x4(%rax,%r11,4), %r9d
subl (%rax,%r11,4), %r9d
jle 0x44dff
movl %r9d, %r14d
movq 0x68(%rsp), %rsi
movq 0xa0(%rsp), %r12
movq %r12, %rbp
movq 0x98(%rsp), %rcx
imulq %rcx, %rbp
addq %rsi, %rbp
addq %rcx, %rsi
movq %rsi, 0x8(%rsp)
shlq $0x2, %r12
xorl %r9d, %r9d
movslq (%rax,%r11,4), %r10
movq 0x60(%rsp), %rcx
leaq (%rcx,%r9,4), %rbx
movslq (%rbx,%r10,4), %r10
subq 0x28(%rsp), %r10
cmpq $0x0, 0x30(%rsp)
je 0x44db8
movq 0x20(%rsp), %rcx
cmpq %rcx, (%rsp)
jl 0x44df3
leaq (%rdx,%r9,4), %rbx
imulq %rdi, %r10
movq 0x40(%rsp), %rcx
leaq (%rcx,%r10,4), %r10
xorl %r15d, %r15d
movslq (%rax,%r11,4), %r13
movl (%r10,%r15,4), %esi
imull (%rbx,%r13,4), %esi
addl %esi, (%rbp,%r15,4)
incq %r15
cmpq %r15, %rdi
jne 0x44d9c
jmp 0x44df3
movq 0x20(%rsp), %rcx
cmpq %rcx, (%rsp)
jl 0x44df3
leaq (%rdx,%r9,4), %r15
movq 0x40(%rsp), %rcx
leaq (%rcx,%r10,4), %r10
movq 0x8(%rsp), %r13
movq %rdi, %rbx
movslq (%rax,%r11,4), %rsi
movl (%r10), %ecx
imull (%r15,%rsi,4), %ecx
addl %ecx, (%r13)
addq %r12, %r13
addq %r8, %r10
decq %rbx
jne 0x44dd8
incq %r9
cmpq %r14, %r9
jne 0x44d5f
movq 0x38(%rsp), %r11
incq %r11
addq $0x4, 0x98(%rsp)
cmpq 0x18(%rsp), %r11
jne 0x44d15
jmp 0x4607c
cmpq $0xf, 0xb0(%rsp)
movaps 0x6c660(%rip), %xmm4 # 0xb1490
movapd 0x6c668(%rip), %xmm5 # 0xb14a0
ja 0x4607c
movq 0xb0(%rsp), %rcx
leaq 0x70db7(%rip), %rsi # 0xb5c04
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rsi
movq %rcx, (%rsp)
movq %rsi, %r10
subq %rsi, %rcx
incq %rcx
leaq (,%rcx,4), %r8
movq $0x0, 0x38(%rsp)
movq 0x10(%rsp), %r9
movq %r9, 0x8(%rsp)
subq 0x10(%rsp), %r9
movq (%rax,%r9,8), %rdi
movq 0x8(%rax,%r9,8), %r11
subq %rdi, %r11
jle 0x44f5d
movq 0x60(%rsp), %rsi
leaq (%rsi,%rdi,8), %r14
leaq (%rdx,%rdi,4), %r15
movq 0x68(%rsp), %rdi
movq 0xa0(%rsp), %r9
movq %r9, %rbp
movq 0x38(%rsp), %rsi
imulq %rsi, %rbp
addq %rdi, %rbp
addq %rsi, %rdi
movq %rdi, 0x20(%rsp)
shlq $0x2, %r9
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
subq 0x28(%rsp), %rdi
cmpq $0x0, 0x30(%rsp)
je 0x44f28
cmpq %r10, (%rsp)
jl 0x44f55
imulq %rcx, %rdi
movq 0x40(%rsp), %rsi
leaq (%rsi,%rdi,4), %rdi
xorl %ebx, %ebx
movl (%rdi,%rbx,4), %r13d
imull (%r15,%r12,4), %r13d
addl %r13d, (%rbp,%rbx,4)
incq %rbx
cmpq %rbx, %rcx
jne 0x44f10
jmp 0x44f55
cmpq %r10, (%rsp)
jl 0x44f55
movq 0x40(%rsp), %rsi
leaq (%rsi,%rdi,4), %r13
movq 0x20(%rsp), %rbx
movq %rcx, %rdi
movl (%r13), %esi
imull (%r15,%r12,4), %esi
addl %esi, (%rbx)
addq %r9, %rbx
addq %r8, %r13
decq %rdi
jne 0x44f3f
incq %r12
cmpq %r11, %r12
jne 0x44eea
movq 0x8(%rsp), %r9
incq %r9
addq $0x4, 0x38(%rsp)
cmpq 0x18(%rsp), %r9
jne 0x44e96
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rsi
movq 0x80(%rsp), %rbx
movq %rsi, %r11
subq %rbx, %r11
incq %r11
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x8(%rcx), %r8
movq %r11, (%rsp)
shlq $0x4, %r11
movq 0x28(%rsp), %rcx
shlq $0x4, %rcx
movq %r8, 0x20(%rsp)
subq %rcx, %r8
movq %r8, 0x38(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x90(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x98(%rsp)
subq 0x10(%rsp), %rdi
movl 0x4(%rax,%rdi,4), %ecx
movslq (%rax,%rdi,4), %rdi
subl %edi, %ecx
jle 0x45137
movq %rdi, %r13
movl %ecx, %ecx
movq 0x60(%rsp), %rdi
leaq (%rdi,%r13,4), %r10
movq 0xa0(%rsp), %rbp
movq %rbp, %r14
imulq 0x90(%rsp), %r14
addq 0xc8(%rsp), %r14
shlq $0x4, %rbp
xorl %r8d, %r8d
movslq (%r10,%r8,4), %r12
cmpq $0x0, 0x30(%rsp)
je 0x450bc
cmpq %rbx, %rsi
jl 0x4512b
subq 0x28(%rsp), %r12
leaq (%r8,%r13), %r15
shlq $0x4, %r15
imulq %r11, %r12
addq 0x20(%rsp), %r12
xorl %edi, %edi
movq (%rsp), %r9
movupd (%rdx,%r15), %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
xorpd %xmm5, %xmm1
movsd -0x8(%r12,%rdi), %xmm2
movsd (%r12,%rdi), %xmm3
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm3, %xmm1
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
movupd (%r14,%rdi), %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, (%r14,%rdi)
addq $0x10, %rdi
decq %r9
jne 0x4506a
jmp 0x4512b
cmpq %rbx, %rsi
jl 0x4512b
leaq (%r8,%r13), %r15
shlq $0x4, %r15
shlq $0x4, %r12
addq 0x38(%rsp), %r12
movq 0x8(%rsp), %r9
movq (%rsp), %rdi
movupd (%rdx,%r15), %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
xorpd %xmm5, %xmm1
movsd -0x8(%r12), %xmm2
movsd (%r12), %xmm3
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm3, %xmm1
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
movupd (%r9), %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, (%r9)
addq %rbp, %r9
addq %r11, %r12
decq %rdi
jne 0x450db
incq %r8
cmpq %rcx, %r8
jne 0x45039
movq 0x98(%rsp), %rdi
incq %rdi
addq $0x10, 0x90(%rsp)
addq $0x10, 0x8(%rsp)
cmpq 0x18(%rsp), %rdi
jne 0x44feb
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rsi
movq 0x80(%rsp), %rbx
movq %rsi, %r11
subq %rbx, %r11
incq %r11
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rcx
leaq 0x8(%rcx), %r8
movq %r11, (%rsp)
shlq $0x4, %r11
movq 0x28(%rsp), %rcx
shlq $0x4, %rcx
movq %r8, 0x20(%rsp)
subq %rcx, %r8
movq %r8, 0x38(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x90(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x98(%rsp)
subq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rax,%rcx,8), %rcx
subq %rdi, %rcx
jle 0x4531d
movq %rdi, %r13
movq 0x60(%rsp), %rdi
leaq (%rdi,%r13,8), %r10
movq 0xa0(%rsp), %rbp
movq %rbp, %r15
imulq 0x90(%rsp), %r15
addq 0xc8(%rsp), %r15
shlq $0x4, %rbp
xorl %r8d, %r8d
movq (%r10,%r8,8), %r12
cmpq $0x0, 0x30(%rsp)
je 0x452a2
cmpq %rbx, %rsi
jl 0x45311
subq 0x28(%rsp), %r12
leaq (%r8,%r13), %r14
shlq $0x4, %r14
imulq %r11, %r12
addq 0x20(%rsp), %r12
xorl %edi, %edi
movq (%rsp), %r9
movupd (%rdx,%r14), %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
xorpd %xmm5, %xmm1
movsd -0x8(%r12,%rdi), %xmm2
movsd (%r12,%rdi), %xmm3
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm3, %xmm1
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
movupd (%r15,%rdi), %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, (%r15,%rdi)
addq $0x10, %rdi
decq %r9
jne 0x45250
jmp 0x45311
cmpq %rbx, %rsi
jl 0x45311
leaq (%r8,%r13), %r14
shlq $0x4, %r14
shlq $0x4, %r12
addq 0x38(%rsp), %r12
movq 0x8(%rsp), %r9
movq (%rsp), %rdi
movupd (%rdx,%r14), %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
xorpd %xmm5, %xmm1
movsd -0x8(%r12), %xmm2
movsd (%r12), %xmm3
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
mulpd %xmm3, %xmm1
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
mulpd %xmm0, %xmm2
addpd %xmm1, %xmm2
movupd (%r9), %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, (%r9)
addq %rbp, %r9
addq %r11, %r12
decq %rdi
jne 0x452c1
incq %r8
cmpq %rcx, %r8
jne 0x4521f
movq 0x98(%rsp), %rcx
incq %rcx
addq $0x10, 0x90(%rsp)
addq $0x10, 0x8(%rsp)
cmpq 0x18(%rsp), %rcx
jne 0x451d1
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rcx
subq 0x80(%rsp), %rcx
incq %rcx
xorl %esi, %esi
movq 0x10(%rsp), %rbx
movq %rbx, (%rsp)
subq 0x10(%rsp), %rbx
movl 0x4(%rax,%rbx,4), %r8d
movslq (%rax,%rbx,4), %r10
subl %r10d, %r8d
jle 0x4546c
movl %r8d, %r8d
movq 0x60(%rsp), %rdi
leaq (%rdi,%r10,4), %r9
leaq (%rdx,%r10,8), %r10
movq 0x68(%rsp), %r11
leaq (%r11,%rbx,8), %r14
xorl %r15d, %r15d
movslq (%r9,%r15,4), %rbx
subq 0x28(%rsp), %rbx
movq 0x80(%rsp), %r12
movq 0x70(%rsp), %r13
cmpq $0x0, 0x30(%rsp)
je 0x4541b
cmpq %r13, %r12
jg 0x45460
imulq %rcx, %rbx
movq 0x40(%rsp), %rdi
leaq (%rdi,%rbx,8), %rbp
decq %r12
movq 0x80(%rsp), %rbx
shlq $0x3, %rbx
movq %rbp, %r13
subq %rbx, %r13
movq 0x8(%r13,%r12,8), %r13
imulq (%r10,%r15,8), %r13
movq 0xa0(%rsp), %rdi
imulq %rsi, %rdi
subq %rbx, %rdi
addq %r11, %rdi
addq %r13, 0x8(%rdi,%r12,8)
incq %r12
cmpq 0x70(%rsp), %r12
jl 0x453dc
jmp 0x45460
cmpq %r13, %r12
jg 0x45460
movq 0x40(%rsp), %rdi
leaq (%rdi,%rbx,8), %rbx
movq %r12, %rdi
subq 0x80(%rsp), %rdi
movq %rdi, %r13
imulq %rcx, %r13
movq (%rbx,%r13,8), %r13
imulq (%r10,%r15,8), %r13
imulq 0xa0(%rsp), %rdi
addq %r13, (%r14,%rdi,8)
leaq 0x1(%r12), %rdi
cmpq 0x70(%rsp), %r12
movq %rdi, %r12
jl 0x45429
incq %r15
cmpq %r8, %r15
jne 0x453a5
movq (%rsp), %rbx
incq %rbx
addq $0x8, %rsi
cmpq 0x18(%rsp), %rbx
jne 0x4536e
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rcx
subq 0x80(%rsp), %rcx
incq %rcx
xorl %esi, %esi
movq 0x10(%rsp), %r8
movq %r8, (%rsp)
subq 0x10(%rsp), %r8
movq 0x8(%rax,%r8,8), %r9
subq (%rax,%r8,8), %r9
jle 0x455b2
movq 0x68(%rsp), %r10
leaq (%r10,%r8,8), %r11
xorl %r14d, %r14d
movq (%rax,%r8,8), %rbx
movq 0x60(%rsp), %rdi
leaq (%rdi,%rbx,8), %rbx
movq (%rbx,%r14,8), %rbx
subq 0x28(%rsp), %rbx
movq 0x80(%rsp), %r12
leaq (%rdx,%r14,8), %r15
movq 0x70(%rsp), %r13
cmpq $0x0, 0x30(%rsp)
je 0x4555d
cmpq %r13, %r12
jg 0x455a6
imulq %rcx, %rbx
movq 0x40(%rsp), %rdi
leaq (%rdi,%rbx,8), %rdi
decq %r12
movq (%rax,%r8,8), %rbx
movq 0x80(%rsp), %r13
shlq $0x3, %r13
movq %rdi, %rbp
subq %r13, %rbp
movq 0x8(%rbp,%r12,8), %rbp
imulq (%r15,%rbx,8), %rbp
movq 0xa0(%rsp), %rbx
imulq %rsi, %rbx
subq %r13, %rbx
addq %r10, %rbx
addq %rbp, 0x8(%rbx,%r12,8)
incq %r12
cmpq 0x70(%rsp), %r12
jl 0x4551a
jmp 0x455a6
cmpq %r13, %r12
jg 0x455a6
movq 0x40(%rsp), %rdi
leaq (%rdi,%rbx,8), %rbx
movq %r12, %rdi
subq 0x80(%rsp), %rdi
movq (%rax,%r8,8), %r13
movq %rdi, %rbp
imulq %rcx, %rbp
movq (%rbx,%rbp,8), %rbp
imulq (%r15,%r13,8), %rbp
imulq 0xa0(%rsp), %rdi
addq %rbp, (%r11,%rdi,8)
leaq 0x1(%r12), %rdi
cmpq 0x70(%rsp), %r12
movq %rdi, %r12
jl 0x4556b
incq %r14
cmpq %r9, %r14
jne 0x454d2
movq (%rsp), %r8
incq %r8
addq $0x8, %rsi
cmpq 0x18(%rsp), %r8
jne 0x454ae
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq %rdi, (%rsp)
movq %rsi, %rcx
subq %rsi, %rdi
incq %rdi
leaq (,%rdi,8), %r8
movq $0x0, 0x38(%rsp)
movq 0x10(%rsp), %r9
movq %r9, 0x8(%rsp)
subq 0x10(%rsp), %r9
movl 0x4(%rax,%r9,4), %r10d
movslq (%rax,%r9,4), %r9
subl %r9d, %r10d
jle 0x456d7
movl %r10d, %r11d
movq 0x60(%rsp), %rsi
leaq (%rsi,%r9,4), %r14
leaq (%rdx,%r9,8), %r15
movq 0x68(%rsp), %r10
movq 0xa0(%rsp), %r9
movq %r9, %rbp
movq 0x38(%rsp), %rsi
imulq %rsi, %rbp
addq %r10, %rbp
addq %rsi, %r10
movq %r10, 0x20(%rsp)
shlq $0x3, %r9
xorl %r12d, %r12d
movslq (%r14,%r12,4), %r10
subq 0x28(%rsp), %r10
cmpq $0x0, 0x30(%rsp)
je 0x456a2
cmpq %rcx, (%rsp)
jl 0x456cf
imulq %rdi, %r10
movq 0x40(%rsp), %rsi
leaq (%rsi,%r10,8), %r10
xorl %ebx, %ebx
movq (%r10,%rbx,8), %r13
imulq (%r15,%r12,8), %r13
addq %r13, (%rbp,%rbx,8)
incq %rbx
cmpq %rbx, %rdi
jne 0x4568a
jmp 0x456cf
cmpq %rcx, (%rsp)
jl 0x456cf
movq 0x40(%rsp), %rsi
leaq (%rsi,%r10,8), %r10
movq 0x20(%rsp), %rbx
movq %rdi, %r13
movq (%r10), %rsi
imulq (%r15,%r12,8), %rsi
addq %rsi, (%rbx)
addq %r9, %rbx
addq %r8, %r10
decq %r13
jne 0x456b9
incq %r12
cmpq %r11, %r12
jne 0x45664
movq 0x8(%rsp), %r9
incq %r9
addq $0x8, 0x38(%rsp)
cmpq 0x18(%rsp), %r9
jne 0x4560d
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rsi
movq %rcx, (%rsp)
movq %rsi, %r10
subq %rsi, %rcx
incq %rcx
leaq (,%rcx,8), %r8
movq $0x0, 0x38(%rsp)
movq 0x10(%rsp), %r9
movq %r9, 0x8(%rsp)
subq 0x10(%rsp), %r9
movq (%rax,%r9,8), %rdi
movq 0x8(%rax,%r9,8), %r11
subq %rdi, %r11
jle 0x457fd
movq 0x60(%rsp), %rsi
leaq (%rsi,%rdi,8), %r14
leaq (%rdx,%rdi,8), %r15
movq 0x68(%rsp), %rdi
movq 0xa0(%rsp), %r9
movq %r9, %rbp
movq 0x38(%rsp), %rsi
imulq %rsi, %rbp
addq %rdi, %rbp
addq %rsi, %rdi
movq %rdi, 0x20(%rsp)
shlq $0x3, %r9
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
subq 0x28(%rsp), %rdi
cmpq $0x0, 0x30(%rsp)
je 0x457c7
cmpq %r10, (%rsp)
jl 0x457f5
imulq %rcx, %rdi
movq 0x40(%rsp), %rsi
leaq (%rsi,%rdi,8), %rdi
xorl %ebx, %ebx
movq (%rdi,%rbx,8), %r13
imulq (%r15,%r12,8), %r13
addq %r13, (%rbp,%rbx,8)
incq %rbx
cmpq %rbx, %rcx
jne 0x457af
jmp 0x457f5
cmpq %r10, (%rsp)
jl 0x457f5
movq 0x40(%rsp), %rsi
leaq (%rsi,%rdi,8), %r13
movq 0x20(%rsp), %rbx
movq %rcx, %rdi
movq (%r13), %rsi
imulq (%r15,%r12,8), %rsi
addq %rsi, (%rbx)
addq %r9, %rbx
addq %r8, %r13
decq %rdi
jne 0x457de
incq %r12
cmpq %r11, %r12
jne 0x45789
movq 0x8(%rsp), %r9
incq %r9
addq $0x8, 0x38(%rsp)
cmpq 0x18(%rsp), %r9
jne 0x45735
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rbx
movq 0x80(%rsp), %rsi
movq %rbx, %rcx
subq %rsi, %rcx
incq %rcx
leaq (,%rcx,4), %r8
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x20(%rsp)
subq 0x10(%rsp), %rdi
movl 0x4(%rax,%rdi,4), %r9d
movslq (%rax,%rdi,4), %rdi
subl %edi, %r9d
jle 0x4593a
movl %r9d, %r11d
movq 0x60(%rsp), %r9
leaq (%r9,%rdi,4), %r14
leaq (%rdx,%rdi,4), %r15
movq 0x68(%rsp), %r10
movq 0xa0(%rsp), %r9
movq %r9, %rbp
movq 0x8(%rsp), %rdi
imulq %rdi, %rbp
addq %r10, %rbp
addq %rdi, %r10
movq %r10, (%rsp)
shlq $0x2, %r9
xorl %r12d, %r12d
movslq (%r14,%r12,4), %rdi
subq 0x28(%rsp), %rdi
cmpq $0x0, 0x30(%rsp)
je 0x458f7
cmpq %rsi, %rbx
jl 0x4592e
imulq %rcx, %rdi
movq 0x40(%rsp), %r10
leaq (%r10,%rdi,4), %rdi
xorl %r10d, %r10d
movss (%r15,%r12,4), %xmm0
mulss (%rdi,%r10,4), %xmm0
addss (%rbp,%r10,4), %xmm0
movss %xmm0, (%rbp,%r10,4)
incq %r10
cmpq %r10, %rcx
jne 0x458d3
jmp 0x4592e
cmpq %rsi, %rbx
jl 0x4592e
movq 0x40(%rsp), %r10
leaq (%r10,%rdi,4), %r10
movq (%rsp), %r13
movq %rcx, %rdi
movss (%r15,%r12,4), %xmm0
mulss (%r10), %xmm0
addss (%r13), %xmm0
movss %xmm0, (%r13)
addq %r9, %r13
addq %r8, %r10
decq %rdi
jne 0x4590c
incq %r12
cmpq %r11, %r12
jne 0x458ad
movq 0x20(%rsp), %rdi
incq %rdi
addq $0x4, 0x8(%rsp)
cmpq 0x18(%rsp), %rdi
jne 0x45857
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rsi
movq %rcx, %rdi
subq %rsi, %rdi
incq %rdi
leaq (,%rdi,4), %r8
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %r10
movq %r10, 0x20(%rsp)
subq 0x10(%rsp), %r10
movq (%rax,%r10,8), %r9
movq 0x8(%rax,%r10,8), %r11
subq %r9, %r11
jle 0x45a71
movq 0x60(%rsp), %r10
leaq (%r10,%r9,8), %r14
leaq (%rdx,%r9,4), %r15
movq 0x68(%rsp), %rbx
movq 0xa0(%rsp), %r9
movq %r9, %rbp
movq 0x8(%rsp), %r10
imulq %r10, %rbp
addq %rbx, %rbp
addq %r10, %rbx
movq %rbx, (%rsp)
shlq $0x2, %r9
xorl %r12d, %r12d
movq (%r14,%r12,8), %r10
subq 0x28(%rsp), %r10
cmpq $0x0, 0x30(%rsp)
je 0x45a2e
cmpq %rsi, %rcx
jl 0x45a65
imulq %rdi, %r10
movq 0x40(%rsp), %rbx
leaq (%rbx,%r10,4), %r10
xorl %ebx, %ebx
movss (%r15,%r12,4), %xmm0
mulss (%r10,%rbx,4), %xmm0
addss (%rbp,%rbx,4), %xmm0
movss %xmm0, (%rbp,%rbx,4)
incq %rbx
cmpq %rbx, %rdi
jne 0x45a0c
jmp 0x45a65
cmpq %rsi, %rcx
jl 0x45a65
movq 0x40(%rsp), %rbx
leaq (%rbx,%r10,4), %r10
movq (%rsp), %r13
movq %rdi, %rbx
movss (%r15,%r12,4), %xmm0
mulss (%r10), %xmm0
addss (%r13), %xmm0
movss %xmm0, (%r13)
addq %r9, %r13
addq %r8, %r10
decq %rbx
jne 0x45a43
incq %r12
cmpq %r11, %r12
jne 0x459e7
movq 0x20(%rsp), %r10
incq %r10
addq $0x4, 0x8(%rsp)
cmpq 0x18(%rsp), %r10
jne 0x45994
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rsi
movq %rcx, %rdi
subq %rsi, %rdi
incq %rdi
leaq (,%rdi,8), %r8
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %r9
movq %r9, 0x20(%rsp)
subq 0x10(%rsp), %r9
movl 0x4(%rax,%r9,4), %r10d
movslq (%rax,%r9,4), %r9
subl %r9d, %r10d
jle 0x45bab
movl %r10d, %r11d
movq 0x60(%rsp), %r10
leaq (%r10,%r9,4), %r14
leaq (%rdx,%r9,8), %r15
movq 0x68(%rsp), %rbx
movq 0xa0(%rsp), %r9
movq %r9, %rbp
movq 0x8(%rsp), %r10
imulq %r10, %rbp
addq %rbx, %rbp
addq %r10, %rbx
movq %rbx, (%rsp)
shlq $0x3, %r9
xorl %r12d, %r12d
movslq (%r14,%r12,4), %r10
subq 0x28(%rsp), %r10
cmpq $0x0, 0x30(%rsp)
je 0x45b68
cmpq %rsi, %rcx
jl 0x45b9f
imulq %rdi, %r10
movq 0x40(%rsp), %rbx
leaq (%rbx,%r10,8), %r10
xorl %ebx, %ebx
movsd (%r15,%r12,8), %xmm0
mulsd (%r10,%rbx,8), %xmm0
addsd (%rbp,%rbx,8), %xmm0
movsd %xmm0, (%rbp,%rbx,8)
incq %rbx
cmpq %rbx, %rdi
jne 0x45b46
jmp 0x45b9f
cmpq %rsi, %rcx
jl 0x45b9f
movq 0x40(%rsp), %rbx
leaq (%rbx,%r10,8), %r10
movq (%rsp), %r13
movq %rdi, %rbx
movsd (%r15,%r12,8), %xmm0
mulsd (%r10), %xmm0
addsd (%r13), %xmm0
movsd %xmm0, (%r13)
addq %r9, %r13
addq %r8, %r10
decq %rbx
jne 0x45b7d
incq %r12
cmpq %r11, %r12
jne 0x45b21
movq 0x20(%rsp), %r9
incq %r9
addq $0x8, 0x8(%rsp)
cmpq 0x18(%rsp), %r9
jne 0x45acb
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rcx
movq 0x80(%rsp), %rsi
movq %rcx, %rdi
subq %rsi, %rdi
incq %rdi
leaq (,%rdi,8), %r8
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %r10
movq %r10, 0x20(%rsp)
subq 0x10(%rsp), %r10
movq (%rax,%r10,8), %r9
movq 0x8(%rax,%r10,8), %r11
subq %r9, %r11
jle 0x45ce2
movq 0x60(%rsp), %r10
leaq (%r10,%r9,8), %r14
leaq (%rdx,%r9,8), %r15
movq 0x68(%rsp), %rbx
movq 0xa0(%rsp), %r9
movq %r9, %rbp
movq 0x8(%rsp), %r10
imulq %r10, %rbp
addq %rbx, %rbp
addq %r10, %rbx
movq %rbx, (%rsp)
shlq $0x3, %r9
xorl %r12d, %r12d
movq (%r14,%r12,8), %r10
subq 0x28(%rsp), %r10
cmpq $0x0, 0x30(%rsp)
je 0x45c9f
cmpq %rsi, %rcx
jl 0x45cd6
imulq %rdi, %r10
movq 0x40(%rsp), %rbx
leaq (%rbx,%r10,8), %r10
xorl %ebx, %ebx
movsd (%r15,%r12,8), %xmm0
mulsd (%r10,%rbx,8), %xmm0
addsd (%rbp,%rbx,8), %xmm0
movsd %xmm0, (%rbp,%rbx,8)
incq %rbx
cmpq %rbx, %rdi
jne 0x45c7d
jmp 0x45cd6
cmpq %rsi, %rcx
jl 0x45cd6
movq 0x40(%rsp), %rbx
leaq (%rbx,%r10,8), %r10
movq (%rsp), %r13
movq %rdi, %rbx
movsd (%r15,%r12,8), %xmm0
mulsd (%r10), %xmm0
addsd (%r13), %xmm0
movsd %xmm0, (%r13)
addq %r9, %r13
addq %r8, %r10
decq %rbx
jne 0x45cb4
incq %r12
cmpq %r11, %r12
jne 0x45c58
movq 0x20(%rsp), %r10
incq %r10
addq $0x8, 0x8(%rsp)
cmpq 0x18(%rsp), %r10
jne 0x45c05
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rbx
movq 0x80(%rsp), %r13
movq %rbx, %rsi
subq %r13, %rsi
incq %rsi
movq 0x40(%rsp), %rcx
leaq 0x4(%rcx), %rdi
leaq (,%rsi,8), %r10
movq 0x28(%rsp), %rcx
leaq (,%rcx,8), %rcx
movq %rdi, 0x20(%rsp)
subq %rcx, %rdi
movq %rdi, 0x38(%rsp)
movq $0x0, 0x90(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x98(%rsp)
subq 0x10(%rsp), %rdi
movl 0x4(%rax,%rdi,4), %ecx
movslq (%rax,%rdi,4), %r8
movq %r8, (%rsp)
subl %r8d, %ecx
jle 0x45e9d
movl %ecx, %ebp
movq 0x60(%rsp), %rcx
movq (%rsp), %rdi
leaq (%rcx,%rdi,4), %r11
movq 0x68(%rsp), %rdi
movq 0xa0(%rsp), %r9
movq %r9, %r14
movq 0x90(%rsp), %rcx
imulq %rcx, %r14
addq %rdi, %r14
addq %rcx, %rdi
movq %rdi, 0x8(%rsp)
shlq $0x3, %r9
xorl %r12d, %r12d
movslq (%r11,%r12,4), %r15
cmpq $0x0, 0x30(%rsp)
je 0x45e33
cmpq %r13, %rbx
jl 0x45e91
subq 0x28(%rsp), %r15
movq (%rsp), %rcx
addq %r12, %rcx
imulq %r10, %r15
addq 0x20(%rsp), %r15
xorl %edi, %edi
movsd (%rdx,%rcx,8), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
xorps %xmm4, %xmm1
movss -0x4(%r15,%rdi,8), %xmm2
movss (%r15,%rdi,8), %xmm3
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm3, %xmm1
unpcklps %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1]
mulps %xmm0, %xmm2
addps %xmm1, %xmm2
movsd (%r14,%rdi,8), %xmm0
addps %xmm2, %xmm0
movlps %xmm0, (%r14,%rdi,8)
incq %rdi
cmpq %rdi, %rsi
jne 0x45ded
jmp 0x45e91
cmpq %r13, %rbx
jl 0x45e91
movq (%rsp), %rcx
addq %r12, %rcx
movq 0x38(%rsp), %rdi
leaq (%rdi,%r15,8), %r15
movq 0x8(%rsp), %rdi
movq %rsi, %r8
movsd (%rdx,%rcx,8), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
xorps %xmm4, %xmm1
movss -0x4(%r15), %xmm2
movss (%r15), %xmm3
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm3, %xmm1
unpcklps %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1]
mulps %xmm0, %xmm2
addps %xmm1, %xmm2
movsd (%rdi), %xmm0
addps %xmm2, %xmm0
movlps %xmm0, (%rdi)
addq %r9, %rdi
addq %r10, %r15
decq %r8
jne 0x45e50
incq %r12
cmpq %rbp, %r12
jne 0x45dc1
movq 0x98(%rsp), %rdi
incq %rdi
addq $0x8, 0x90(%rsp)
cmpq 0x18(%rsp), %rdi
jne 0x45d62
jmp 0x4607c
movq 0x18(%rsp), %rcx
cmpq %rcx, 0x58(%rsp)
jg 0x4607c
movq 0x70(%rsp), %rbx
movq 0x80(%rsp), %r13
movq %rbx, %rsi
subq %r13, %rsi
incq %rsi
movq 0x40(%rsp), %rcx
leaq 0x4(%rcx), %rdi
leaq (,%rsi,8), %r10
movq 0x28(%rsp), %rcx
leaq (,%rcx,8), %rcx
movq %rdi, 0x20(%rsp)
subq %rcx, %rdi
movq %rdi, 0x38(%rsp)
movq $0x0, 0x90(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x98(%rsp)
subq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rax,%rcx,8), %rbp
movq %rdi, (%rsp)
subq %rdi, %rbp
jle 0x4605d
movq 0x60(%rsp), %rcx
movq (%rsp), %rdi
leaq (%rcx,%rdi,8), %r11
movq 0x68(%rsp), %rdi
movq 0xa0(%rsp), %r9
movq %r9, %r14
movq 0x90(%rsp), %rcx
imulq %rcx, %r14
addq %rdi, %r14
addq %rcx, %rdi
movq %rdi, 0x8(%rsp)
shlq $0x3, %r9
xorl %r12d, %r12d
movq (%r11,%r12,8), %r15
cmpq $0x0, 0x30(%rsp)
je 0x45ff3
cmpq %r13, %rbx
jl 0x46051
subq 0x28(%rsp), %r15
movq (%rsp), %rcx
addq %r12, %rcx
imulq %r10, %r15
addq 0x20(%rsp), %r15
xorl %edi, %edi
movsd (%rdx,%rcx,8), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
xorps %xmm4, %xmm1
movss -0x4(%r15,%rdi,8), %xmm2
movss (%r15,%rdi,8), %xmm3
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm3, %xmm1
unpcklps %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1]
mulps %xmm0, %xmm2
addps %xmm1, %xmm2
movsd (%r14,%rdi,8), %xmm0
addps %xmm2, %xmm0
movlps %xmm0, (%r14,%rdi,8)
incq %rdi
cmpq %rdi, %rsi
jne 0x45fad
jmp 0x46051
cmpq %r13, %rbx
jl 0x46051
movq (%rsp), %rcx
addq %r12, %rcx
movq 0x38(%rsp), %rdi
leaq (%rdi,%r15,8), %r15
movq 0x8(%rsp), %rdi
movq %rsi, %r8
movsd (%rdx,%rcx,8), %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
xorps %xmm4, %xmm1
movss -0x4(%r15), %xmm2
movss (%r15), %xmm3
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
unpcklps %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
mulps %xmm3, %xmm1
unpcklps %xmm2, %xmm2 # xmm2 = xmm2[0,0,1,1]
mulps %xmm0, %xmm2
addps %xmm1, %xmm2
movsd (%rdi), %xmm0
addps %xmm2, %xmm0
movlps %xmm0, (%rdi)
addq %r9, %rdi
addq %r10, %r15
decq %r8
jne 0x46010
incq %r12
cmpq %rbp, %r12
jne 0x45f81
movq 0x98(%rsp), %rcx
incq %rcx
addq $0x8, 0x90(%rsp)
cmpq 0x18(%rsp), %rcx
jne 0x45f23
movq 0x40(%rsp), %rdi
callq 0x3330
movq 0x150(%rsp), %rcx
incq %rcx
leaq 0x96028(%rip), %r13 # 0xdc0c0
movq (%r13), %rax
movq 0x138(%rsp), %rbp
cmpq 0x58(%rax,%rbp), %rcx
movq 0x130(%rsp), %r15
movq 0x148(%rsp), %r14
jl 0x44aba
movq 0x128(%rsp), %rbx
incq %rbx
cmpq 0xb8(%rsp), %rbx
jne 0x4499a
cmpl $0x0, 0xc0(%rsp)
je 0x460f0
movq (%r13), %rax
movq 0x38(%rax,%rbp), %rdi
callq 0x6979c
movq %r15, %rax
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/sparse.array.c |
MA_chop_stack | public Boolean MA_chop_stack(Integer memhandle)/*the block to deallocate up to*/
{
AD *ad; /* AD for memhandle */
#ifdef STATS
ma_stats.calls[(int)FID_MA_chop_stack]++;
#endif /* STATS */
#ifdef VERIFY
if (ma_auto_verify && !MA_verify_allocator_stuff())
return MA_FALSE;
#endif /* VERIFY */
/* verify memhandle and convert to AD */
if (!mh2ad(memhandle, &ad, BL_Stack, "MA_chop_stack"))
return MA_FALSE;
/* delete block and all blocks above it from used list */
#ifdef STATS
ma_stats.sblocks -=
list_delete_many(&ma_sused, ad_le, (Pointer)ad, mh_free);
#else
(void)list_delete_many(&ma_sused, ad_le, (Pointer)ad, mh_free);
#endif /* STATS */
/* pop block and all blocks above it from stack */
#ifdef STATS
ma_stats.sbytes -= (((Pointer)ad + ad->nbytes) - ma_sp);
#endif /* STATS */
ma_sp = (Pointer)ad + ad->nbytes;
/* success */
return MA_TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
incq 0x8693e(%rip) # 0xdc128
leaq 0x617b1(%rip), %rcx # 0xb6fa2
movq %rsp, %rsi
movl $0x2, %edx
callq 0x558dd
testq %rax, %rax
je 0x558cc
movq (%rsp), %r13
movq 0x86a16(%rip), %rbx # 0xdc228
xorl %eax, %eax
testq %rbx, %rbx
je 0x558a2
leaq 0x86b5c(%rip), %r14 # 0xdc380
leaq 0x869fd(%rip), %rbp # 0xdc228
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r13, %rbx
jbe 0x5583b
movq %rbx, %r12
jmp 0x55896
movq %rbx, %rdi
callq 0x57509
cmpq $-0x1, %rax
je 0x55853
movq %rax, %rdi
callq 0x57437
jmp 0x55880
movq %r14, %rdi
leaq 0x61d5e(%rip), %rsi # 0xb75bb
movq %rbx, %rdx
xorl %eax, %eax
callq 0x30a0
movl $0x1, %edi
movl $0x1, %esi
leaq 0x61d71(%rip), %rdx # 0xb75e9
movq %r14, %rcx
callq 0x5709f
leaq 0x40(%r12), %rax
testq %r12, %r12
movq 0x40(%rbx), %rcx
cmoveq %rbp, %rax
movq %rcx, (%rax)
incl %r15d
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
jne 0x55831
movslq %r15d, %rax
subq %rax, 0x8684f(%rip) # 0xdc0f8
addq 0x38(%r13), %r13
movq 0x86994(%rip), %rax # 0xdc248
subq %r13, %rax
addq %rax, 0x8684a(%rip) # 0xdc108
movq %r13, 0x86983(%rip) # 0xdc248
movl $0x1, %eax
jmp 0x558ce
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/ma/ma.c |
ga_f2c_get_cmd_args | void ga_f2c_get_cmd_args(int *argc, char ***argv)
{
Integer i=0;
int iargc=F2C_IARGC();
char **iargv=NULL;
if (iargc > F2C_GETARG_ARGV_MAX) {
printf("ga_f2c_get_cmd_args: too many cmd line args");
armci_msg_abort(1);
}
iargv = (char**)malloc(sizeof(char*)*F2C_GETARG_ARGV_MAX);
if (!iargv) {
printf("ga_f2c_get_cmd_args: malloc iargv failed");
armci_msg_abort(1);
}
for (i=0; i<iargc; i++) {
char fstring[F2C_GETARG_ARGLEN_MAX];
char cstring[F2C_GETARG_ARGLEN_MAX];
F2C_GETARG(&i, fstring, F2C_GETARG_ARGLEN_MAX);
ga_f2cstring(fstring, F2C_GETARG_ARGLEN_MAX,
cstring, F2C_GETARG_ARGLEN_MAX);
iargv[i] = strdup(cstring);
}
*argc = iargc;
*argv = iargv;
iargv[iargc] = 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq $0x0, (%rsp)
xorl %eax, %eax
callq 0x57bc0
movq %rax, %rbx
cmpl $0x100, %ebx # imm = 0x100
jl 0x57abd
leaq 0x5fedc(%rip), %rdi # 0xb7988
xorl %eax, %eax
callq 0x3050
movl $0x1, %edi
callq 0x35a0
movl $0x7f8, %edi # imm = 0x7F8
callq 0x33b0
movq %rax, %r12
testq %rax, %rax
jne 0x57ae7
leaq 0x5fede(%rip), %rdi # 0xb79b4
xorl %eax, %eax
callq 0x3050
movl $0x1, %edi
callq 0x35a0
movq %rbx, 0x8(%rsp)
movslq %ebx, %r14
movq $0x0, (%rsp)
testq %r14, %r14
jle 0x57b8c
movq %rsp, %r13
leaq 0x120(%rsp), %rbp
movl $0xfe, %r15d
leaq 0x20(%rsp), %rbx
movq %r13, %rdi
movq %rbp, %rsi
movl $0xff, %edx
callq 0x57be0
movl $0xff, %ecx
movl $0x100, %eax # imm = 0x100
movl $0xff, %edx
subq $0x1, %rdx
jb 0x57b4c
decl %eax
cmpb $0x20, 0x11f(%rsp,%rcx)
movq %rdx, %rcx
je 0x57b35
jmp 0x57b4e
xorl %eax, %eax
cmpl %r15d, %eax
movl $0xfe, %ecx
cmovll %eax, %ecx
movslq %ecx, %rdx
movb $0x0, 0x20(%rsp,%rdx)
testl %eax, %eax
je 0x57b70
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3510
movq (%rsp), %rcx
movq %rax, (%r12,%rcx,8)
incq %rcx
movq %rcx, (%rsp)
cmpq %r14, %rcx
jl 0x57b16
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq %r12, (%rax)
movq $0x0, (%r12,%r14,8)
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
| /GlobalArrays[P]ga/gaf2c/gaf2c.c |
PARMCI_Memat | void* PARMCI_Memat(armci_meminfo_t *meminfo, long offset)
{
void *ptr=NULL;
int rank;
comex_group_rank(COMEX_GROUP_WORLD, &rank);
if(meminfo==NULL) comex_error("PARMCI_Memat: Invalid arg #1 (NULL ptr)",0);
if(meminfo->cpid==rank) { ptr = meminfo->addr; return ptr; }
ptr = meminfo->addr;
return ptr;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
xorl %edi, %edi
callq 0x5cf71
testq %rbx, %rbx
jne 0x585e8
leaq 0x5f5ee(%rip), %rdi # 0xb7bcf
xorl %esi, %esi
callq 0x35cf
movq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
| /GlobalArrays[P]ga/comex/src-armci/armci.c |
PARMCI_NbAccS | int PARMCI_NbAccS(int optype, void *scale, void *src_ptr, int *src_stride_arr, void *dst_ptr, int *dst_stride_arr, int *count, int stride_levels, int proc, armci_hdl_t *nb_handle)
{
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_levels; i++) lcount *= count[i];
iret = comex_nbacc(optype, scale, src_ptr, dst_ptr, lcount, proc,
COMEX_GROUP_WORLD, nb_handle);
} else {
iret = comex_nbaccs(optype, scale, src_ptr, src_stride_arr, dst_ptr,
dst_stride_arr, count, stride_levels, proc, COMEX_GROUP_WORLD, nb_handle);
}
return iret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, 0x8(%rsp)
movq %rsi, %rbp
movl %edi, %ebx
movl 0x58(%rsp), %r13d
movq 0x50(%rsp), %r12
movq %rcx, %rdi
movq %r9, %rsi
movq %r12, %rdx
movl %r13d, %ecx
callq 0x57edb
testl %eax, %eax
je 0x58749
movq 0x8(%rsp), %rdx
movq 0x68(%rsp), %r10
movq 0x10(%rsp), %rcx
movl 0x60(%rsp), %r9d
testl %r13d, %r13d
js 0x5877c
incl %r13d
movl $0x1, %r8d
xorl %eax, %eax
imull (%r12,%rax,4), %r8d
incq %rax
cmpq %rax, %r13
jne 0x5873a
jmp 0x58782
subq $0x8, %rsp
movl %ebx, %edi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rcx
movq 0x18(%rsp), %r8
movq %r14, %r9
pushq 0x70(%rsp)
pushq $0x0
movl 0x78(%rsp), %eax
pushq %rax
pushq %r13
pushq %r12
callq 0x5c4d1
addq $0x48, %rsp
jmp 0x58794
movl $0x1, %r8d
movl %ebx, %edi
movq %rbp, %rsi
pushq %r10
pushq $0x0
callq 0x5c446
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/comex/src-armci/armci.c |
armci_msg_bcast_scope | void armci_msg_bcast_scope(int scope, void* buffer, int len, int root)
{
if (SCOPE_ALL == scope || SCOPE_MASTERS == scope) {
armci_msg_bcast(buffer, len, root);
}
else if (SCOPE_NODE == scope) {
MPI_Comm comm;
assert(buffer != NULL);
comex_group_comm(ARMCI_Node_group,&comm);
MPI_Bcast(buffer, len, MPI_BYTE, root, comm);
}
else {
comex_error("unsupported armci_msg_bcast_scope scope", 1);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
cmpl $0x153, %edi # imm = 0x153
je 0x594b3
cmpl $0x151, %edi # imm = 0x151
je 0x594c9
cmpl $0x14d, %edi # imm = 0x14D
jne 0x59503
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x59148
testq %r14, %r14
je 0x5951e
leaq 0x832cf(%rip), %rax # 0xdc7a4
movl (%rax), %edi
movq %rsp, %r15
movq %r15, %rsi
callq 0x5cfc7
movq (%r15), %r8
movq 0x7d9fc(%rip), %rdx # 0xd6ee8
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %ecx
callq 0x3090
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5eb79(%rip), %rdi # 0xb8083
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x35cf
leaq 0x5eb1d(%rip), %rdi # 0xb8042
leaq 0x5ea15(%rip), %rsi # 0xb7f41
leaq 0x5eb1e(%rip), %rcx # 0xb8051
movl $0x14e, %edx # imm = 0x14E
callq 0x3180
| /GlobalArrays[P]ga/comex/src-armci/message.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_default_group());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
cmpl $0x151, %edi # imm = 0x151
jne 0x59dd7
leaq 0x7d380(%rip), %rax # 0xd7140
cmpl $0x2, (%rax)
movl $0xfffffffe, %r8d # imm = 0xFFFFFFFE
jl 0x59de8
leaq 0x829d2(%rip), %rax # 0xdc7a4
movl (%rax), %r8d
jmp 0x59de8
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x590dc
movl (%r12), %r8d
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x599d4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/comex/src-armci/message.c |
armci_exchange_address_grp | void armci_exchange_address_grp(void *ptr_arr[], int n, ARMCI_Group *group)
{
comex_error("armci_exchange_address_grp not implemented", 1);
#if 0
MPI_Datatype mpi_datatype;
if (sizeof(void*) == sizeof(int)) {
mpi_datatype = MPI_INT;
}
else if (sizeof(void*) == sizeof(long)) {
mpi_datatype = MPI_LONG;
}
else if (sizeof(void*) == sizeof(long long)) {
mpi_datatype = MPI_LONG_LONG;
}
else {
comex_error("armci_exchange_address_grp bad size", 1);
}
MPI_Allgather(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL,
ptr_ar, n, mpi_datatype, get_comm(group));
#endif
} | leaq 0x5e3cd(%rip), %rdi # 0xb8322
movl $0x1, %esi
jmp 0x35cf
| /GlobalArrays[P]ga/comex/src-armci/message.c |
send_fence_message | static void _send_fence_message(int proc, int *notify)
{
header_t *header = NULL;
#if DEBUG
printf("[%d] _send_fence_message(proc=%d notify=%p)\n",
l_state.rank, proc, notify);
#endif
/* create and prepare the header */
header = _my_malloc(sizeof(header_t));
assert(header);
header->operation = OP_FENCE_REQUEST;
header->remote_address = NULL;
header->local_address = NULL;
header->length = 0;
header->notify_address = notify;
_mq_push(proc, (char*)header, sizeof(header_t));
_make_progress_if_needed();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x28, %edi
callq 0x5ae88
movl $0x9, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x0, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl %ebp, %edi
movq %rax, %rsi
movl $0x28, %edx
callq 0x5c0df
leaq 0x80c21(%rip), %rax # 0xdc7d0
cmpl $0x8, 0x1c(%rax)
jl 0x5bbc0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5a600
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /GlobalArrays[P]ga/comex/src-mpi/comex.c |
mq_push | static void _mq_push(int dest, char *message, int count)
{
message_t *mq = NULL;
mq = _my_malloc(sizeof(message_t));
assert(mq);
mq->next = NULL;
mq->dest = dest;
mq->message = message;
_my_isend(message, count, MPI_CHAR, dest, COMEX_TAG,
l_state.world_comm, &(mq->request));
if (l_state.mq_tail) {
l_state.mq_tail->next = mq;
l_state.mq_tail = mq;
}
else {
l_state.mq_head = mq;
l_state.mq_tail = mq;
}
++l_state.mq_size;
assert(l_state.mq_size >= 0);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %ebp
movl $0x20, %edi
callq 0x5ae88
movq $0x0, (%rax)
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
cmpl $-0x1, %ebp
je 0x5c178
movq %rax, %rbx
addq $0x18, %rax
leaq 0x806b2(%rip), %r12 # 0xdc7d0
movq (%r12), %r9
movq %rax, (%rsp)
movq 0x7adcb(%rip), %rdx # 0xd6ef8
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %ecx
movl $0x6be8, %r8d # imm = 0x6BE8
callq 0x3110
movq 0x28(%r12), %rax
leaq 0x20(%r12), %rcx
testq %rax, %rax
cmovneq %rax, %rcx
movq %rbx, (%rcx)
movq %rbx, 0x28(%r12)
movl 0x1c(%r12), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1c(%r12)
cmpl $-0x2, %eax
jle 0x5c197
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5caf7(%rip), %rdi # 0xb8c76
leaq 0x5c41c(%rip), %rsi # 0xb85a2
leaq 0x5cb00(%rip), %rcx # 0xb8c8d
movl $0x80, %edx
callq 0x3180
leaq 0x5c986(%rip), %rdi # 0xb8b24
leaq 0x5c3fd(%rip), %rsi # 0xb85a2
leaq 0x5caaa(%rip), %rcx # 0xb8c56
movl $0xc8, %edx
callq 0x3180
| /GlobalArrays[P]ga/comex/src-mpi/comex.c |
comex_getv | int comex_getv(
comex_giov_t *iov, int iov_len,
int proc, comex_group_t group)
{
int i;
for (i=0; i<iov_len; ++i) {
int j;
void **src = iov[i].src;
void **dst = iov[i].dst;
int bytes = iov[i].bytes;
int count = iov[i].count;
for (j=0; j<count; ++j) {
comex_get(src[j], dst[j], bytes, proc, group);
}
}
return COMEX_SUCCESS;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
testl %esi, %esi
jle 0x5c61b
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %eax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
movq %rax, 0x18(%rsp)
leaq (%rax,%rax,2), %rax
movq 0x8(%rsp), %rdx
movslq 0x10(%rdx,%rax,8), %r14
testq %r14, %r14
jle 0x5c60c
movq 0x8(%rsp), %rdx
movq (%rdx,%rax,8), %rdi
movq %rdi, 0x20(%rsp)
movq 0x8(%rdx,%rax,8), %r13
movl 0x14(%rdx,%rax,8), %r15d
xorl %ebx, %ebx
movq 0x20(%rsp), %rax
movq (%rax,%rbx,8), %rdi
movq (%r13,%rbx,8), %rsi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x5b01d
incq %rbx
cmpq %rbx, %r14
jne 0x5c5e8
movq 0x18(%rsp), %rax
incq %rax
cmpq 0x10(%rsp), %rax
jne 0x5c5b6
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/comex/src-mpi/comex.c |
acc | static inline void _acc(
const int op,
const int bytes,
void * const restrict dst,
const void * const restrict src,
const void * const restrict scale)
{
#define ACC_BLAS(COMEX_TYPE, C_TYPE, LETTER) \
if (op == COMEX_TYPE) { \
const BLAS_INT ONE = 1; \
const BLAS_INT N = bytes/sizeof(C_TYPE); \
BLAS_##LETTER##AXPY(&N, scale, src, &ONE, dst, &ONE); \
} else
#define ACC(WHICH, COMEX_TYPE, C_TYPE) \
if (op == COMEX_TYPE) { \
int m; \
const int m_lim = bytes/sizeof(C_TYPE); \
C_TYPE * const restrict iterator = (C_TYPE * const restrict)dst; \
const C_TYPE * const restrict value = (const C_TYPE * const restrict)src;\
const C_TYPE calc_scale = *(const C_TYPE * const restrict)scale; \
for (m = 0 ; m < m_lim; ++m) { \
IADD_SCALE_##WHICH(iterator[m], value[m], calc_scale); \
} \
} else
#if HAVE_BLAS
ACC_BLAS(COMEX_ACC_DBL, double, D)
ACC_BLAS(COMEX_ACC_FLT, float, S)
ACC(REG, COMEX_ACC_INT, int)
ACC(REG, COMEX_ACC_LNG, long)
ACC_BLAS(COMEX_ACC_DCP, DoubleComplex, Z)
ACC_BLAS(COMEX_ACC_CPL, SingleComplex, C)
#else
ACC(REG, COMEX_ACC_DBL, double)
ACC(REG, COMEX_ACC_FLT, float)
ACC(REG, COMEX_ACC_INT, int)
ACC(REG, COMEX_ACC_LNG, long)
ACC(CPL, COMEX_ACC_DCP, DoubleComplex)
ACC(CPL, COMEX_ACC_CPL, SingleComplex)
#endif
{
#ifdef COMEX_ASSERT
COMEX_ASSERT(0);
#else
assert(0);
#endif
}
#undef ACC_BLAS
#undef ACC
} | addl $-0x25, %edi
cmpl $0x5, %edi
ja 0x5ceff
leaq 0x5b7ad(%rip), %rax # 0xb8530
movslq (%rax,%rdi,4), %rdi
addq %rax, %rdi
jmpq *%rdi
sarl $0x2, %esi
testl %esi, %esi
jle 0x5cefe
movl (%r8), %eax
movl %esi, %esi
xorl %edi, %edi
movl (%rcx,%rdi,4), %r8d
imull %eax, %r8d
addl %r8d, (%rdx,%rdi,4)
incq %rdi
cmpq %rdi, %rsi
jne 0x5cd9e
jmp 0x5cefe
sarl $0x4, %esi
testl %esi, %esi
jle 0x5cefe
movupd (%r8), %xmm0
movl %esi, %eax
shlq $0x4, %rax
xorl %esi, %esi
movapd 0x546c9(%rip), %xmm1 # 0xb14a0
movapd %xmm0, %xmm2
shufpd $0x1, %xmm0, %xmm2 # xmm2 = xmm2[1],xmm0[0]
movsd (%rcx,%rsi), %xmm3
movsd 0x8(%rcx,%rsi), %xmm4
movapd %xmm4, %xmm5
xorpd %xmm1, %xmm5
unpcklpd %xmm4, %xmm5 # xmm5 = xmm5[0],xmm4[0]
mulpd %xmm2, %xmm5
unpcklpd %xmm3, %xmm3 # xmm3 = xmm3[0,0]
mulpd %xmm0, %xmm3
addpd %xmm5, %xmm3
movupd (%rdx,%rsi), %xmm4
addpd %xmm3, %xmm4
movupd %xmm4, (%rdx,%rsi)
addq $0x10, %rsi
cmpq %rsi, %rax
jne 0x5cde0
jmp 0x5cefe
sarl $0x2, %esi
testl %esi, %esi
jle 0x5cefe
movss (%r8), %xmm0
movl %esi, %eax
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm1
mulss %xmm0, %xmm1
addss (%rdx,%rsi,4), %xmm1
movss %xmm1, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x5ce37
jmp 0x5cefe
sarl $0x3, %esi
testl %esi, %esi
jle 0x5cefe
movsd (%r8), %xmm0
movl %esi, %eax
xorl %esi, %esi
movaps 0x5461e(%rip), %xmm1 # 0xb1490
movaps %xmm0, %xmm2
shufps $0xe1, %xmm0, %xmm2 # xmm2 = xmm2[1,0],xmm0[2,3]
movss (%rcx,%rsi,8), %xmm3
movss 0x4(%rcx,%rsi,8), %xmm4
movaps %xmm4, %xmm5
xorps %xmm1, %xmm5
unpcklps %xmm4, %xmm5 # xmm5 = xmm5[0],xmm4[0],xmm5[1],xmm4[1]
mulps %xmm2, %xmm5
unpcklps %xmm3, %xmm3 # xmm3 = xmm3[0,0,1,1]
mulps %xmm0, %xmm3
addps %xmm5, %xmm3
movsd (%rdx,%rsi,8), %xmm4
addps %xmm3, %xmm4
movlps %xmm4, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x5ce79
jmp 0x5cefe
sarl $0x3, %esi
testl %esi, %esi
jle 0x5cefe
movsd (%r8), %xmm0
movl %esi, %eax
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%rsi,8), %xmm1
movsd %xmm1, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x5cebf
jmp 0x5cefe
sarl $0x3, %esi
testl %esi, %esi
jle 0x5cefe
movq (%r8), %rax
movl %esi, %esi
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
imulq %rax, %r8
addq %r8, (%rdx,%rdi,8)
incq %rdi
cmpq %rdi, %rsi
jne 0x5ceea
retq
pushq %rax
leaq 0x5bb06(%rip), %rdi # 0xb8a0d
leaq 0x5bc4b(%rip), %rsi # 0xb8b59
leaq 0x5bc9f(%rip), %rcx # 0xb8bb4
movl $0x95, %edx
callq 0x3180
nop
| /GlobalArrays[P]ga/comex/src-common/acc.h |
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())
#else
if (!ARMCIinitialized)
#endif
{
/* assure that GA will not alocate more shared memory than specified */
if(GA_memory_limited) ARMCI_Set_shm_limit(GA_total_memory);
if (_ga_initialize_c) {
if (_ga_initialize_args) {
ARMCI_Init_args(_ga_argc, _ga_argv);
}
else {
ARMCI_Init();
}
}
else if (_ga_initialize_f) {
_ga_argc = malloc(sizeof(int));
_ga_argv = malloc(sizeof(char**));
if (!_ga_argc) pnga_error("malloc argc failed",1);
ga_f2c_get_cmd_args(_ga_argc, _ga_argv);
ARMCI_Init_args(_ga_argc, _ga_argv);
}
else {
pnga_error("pnga_initialize called outside of C or F APIs",1);
}
ARMCIinitialized = 1;
}
GA_Default_Proc_Group = -1;
/* zero in pointers in GA array */
_ga_main_data_structure
= (global_array_t *)malloc(sizeof(global_array_t)*MAX_ARRAYS);
_proc_list_main_data_structure
= (proc_list_t *)malloc(sizeof(proc_list_t)*MAX_ARRAYS);
if(!_ga_main_data_structure)
pnga_error("ga_init:malloc ga failed",0);
if(!_proc_list_main_data_structure)
pnga_error("ga_init:malloc proc_list failed",0);
GA = _ga_main_data_structure;
PGRP_LIST = _proc_list_main_data_structure;
for(i=0;i<MAX_ARRAYS; i++) {
GA[i].ptr = (char**)0;
GA[i].mapc = (C_Integer*)0;
GA[i].rstrctd_list = (C_Integer*)0;
GA[i].rank_rstrctd = (C_Integer*)0;
GA[i].property = NO_PROPERTY;
GA[i].mem_dev_set = 0;
#ifdef ENABLE_CHECKPOINT
GA[i].record_id = 0;
#endif
GA[i].actv = 0;
GA[i].p_handle = GA_Init_Proc_Group;
GA[i].overlay = 0;
PGRP_LIST[i].map_proc_list = (int*)0;
PGRP_LIST[i].inv_map_proc_list = (int*)0;
PGRP_LIST[i].actv = 0;
}
bzero(&GAstat,sizeof(GAstat));
/* initialize some data structures used in non-blocking communication */
gai_nb_init();
GAnproc = (Integer)armci_msg_nproc();
/* Allocate arrays used by library */
mapALL = (Integer*)malloc((GAnproc+MAXDIM-1)*sizeof(Integer*));
GAme = (Integer)armci_msg_me();
if(GAme<0 || GAme>GAnproc)
pnga_error("ga_init:message-passing initialization problem: my ID=",GAme);
MPme= (Integer)armci_msg_me();
gai_init_onesided();
/* set activity status for all arrays to inactive */
for(i=0;i<_max_global_array;i++)GA[i].actv=0;
for(i=0;i<_max_global_array;i++)GA[i].actv_handle=0;
/* Create proc list for mirrored arrays */
PGRP_LIST[0].map_proc_list = (int*)malloc(GAnproc*sizeof(int)*2);
PGRP_LIST[0].inv_map_proc_list = PGRP_LIST[0].map_proc_list + GAnproc;
for (i=0; i<GAnproc; i++) PGRP_LIST[0].map_proc_list[i] = -1;
for (i=0; i<GAnproc; i++) PGRP_LIST[0].inv_map_proc_list[i] = -1;
nnode = pnga_cluster_nodeid();
nproc = pnga_cluster_nprocs(nnode);
zero = 0;
j = pnga_cluster_procid(nnode, zero);
PGRP_LIST[0].parent = -1;
PGRP_LIST[0].actv = 1;
PGRP_LIST[0].map_nproc = nproc;
PGRP_LIST[0].mirrored = 1;
for (i=0; i<nproc; i++) {
PGRP_LIST[0].map_proc_list[i+j] = i;
PGRP_LIST[0].inv_map_proc_list[i] = i+j;
}
/* Set up group for doing cluster merge. Start by checking if
* number of procs per node is the same for all nodes */
i = nproc;
pnga_pgroup_gop(GA_World_Proc_Group,pnga_type_f2c(MT_F_INT),&i,1,"max");
j = nproc;
pnga_pgroup_gop(GA_World_Proc_Group,pnga_type_f2c(MT_F_INT),&j,1,"min");
if (i == j) {
/* construct a group that containing all processors with the same local
* proc ID across all nodes in the system */
Integer numnodes = pnga_cluster_nnodes();
Integer *nodelist = (Integer*)malloc(numnodes*sizeof(Integer));
Integer myproc = GAme-pnga_cluster_procid(nnode,zero);
for (i=0; i<numnodes; i++) {
nodelist[i] = i*nproc+myproc;
}
_mirror_gop_grp = pnga_pgroup_create(nodelist,numnodes);
free(nodelist);
} else {
_mirror_gop_grp = GA_World_Proc_Group;
}
/* Allocate memory for update flags and signal*/
bytes = 2*MAXDIM*sizeof(int);
GA_Update_Flags = (int**)malloc(GAnproc*sizeof(void*));
if (!GA_Update_Flags)
pnga_error("ga_init: Failed to initialize GA_Update_Flags",(int)GAme);
if (ARMCI_Malloc((void**)GA_Update_Flags, (armci_size_t) bytes))
pnga_error("ga_init:Failed to initialize memory for update flags",GAme);
if(GA_Update_Flags[GAme]==NULL)pnga_error("ga_init:ARMCIMalloc failed",GAme);
bytes = sizeof(int);
GA_Update_Signal = ARMCI_Malloc_local((armci_size_t) bytes);
/* Zero update flags */
for (i=0; i<2*MAXDIM; i++) {
GA_Update_Flags[GAme][i] = 0;
}
/* set MA error function */
MA_set_error_callback(ARMCI_Error);
GAinitialized = 1;
#ifdef PROFILE_OLD
ga_profile_init();
#endif
#ifdef ENABLE_CHECKPOINT
{
Integer tmplist[1000];
Integer tmpcount;
tmpcount = GAnproc-ga_spare_procs;
for(i=0;i<tmpcount;i++)
tmplist[i]=i;
ga_group_is_for_ft=1;
GA_Default_Proc_Group = pnga_pgroup_create(tmplist,tmpcount);
ga_group_is_for_ft=0;
if(GAme>=tmpcount)
ga_irecover(0);
printf("\n%d:here done with initialize\n",GAme);
}
#endif
/* create duplicate of world communicator */
#ifdef MSG_COMMS_MPI
comm = GA_MPI_Comm_pgroup(-1);
MPI_Comm_dup(comm, &GA_MPI_World_comm_dup);
#endif
sai_init_sparse_arrays();
GA_Internal_Threadsafe_Unlock();
} | cmpb $0x0, 0x7f44a(%rip) # 0xdc8f0
jne 0x5dadc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, 0x7f433(%rip) # 0xdc8f4
jne 0x5d590
cmpb $0x1, 0x7f42a(%rip) # 0xdc8f8
jne 0x5d4dc
movq 0x79ca1(%rip), %rdi # 0xd7178
callq 0x58eec
leaq 0x81571(%rip), %rax # 0xdea54
cmpl $0x0, (%rax)
je 0x5d50a
leaq 0x81561(%rip), %rax # 0xdea50
cmpl $0x0, (%rax)
je 0x5d56f
leaq 0x81545(%rip), %rax # 0xdea40
movq (%rax), %rdi
leaq 0x81543(%rip), %rax # 0xdea48
movq (%rax), %rsi
jmp 0x5d568
leaq 0x7ac93(%rip), %rax # 0xd81a4
cmpl $0x0, (%rax)
je 0x5d578
movl $0x4, %edi
callq 0x33b0
movq %rax, %rbx
leaq 0x81516(%rip), %r14 # 0xdea40
movq %rax, (%r14)
movl $0x8, %edi
callq 0x33b0
leaq 0x8150a(%rip), %r15 # 0xdea48
movq %rax, (%r15)
testq %rbx, %rbx
jne 0x5d557
leaq 0x5bdb9(%rip), %rdi # 0xb9306
movl $0x1, %esi
callq 0x18f07
movq (%r14), %rdi
movq (%r15), %rsi
callq 0x57a70
movq (%r14), %rdi
movq (%r15), %rsi
callq 0x58fb3
jmp 0x5d589
xorl %eax, %eax
callq 0x58fac
jmp 0x5d589
leaq 0x5bd9a(%rip), %rdi # 0xb9319
movl $0x1, %esi
callq 0x18f07
movb $0x1, 0x7f364(%rip) # 0xdc8f4
leaq 0x79bd9(%rip), %rax # 0xd7170
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movl $0x1b40000, %edi # imm = 0x1B40000
callq 0x33b0
movq %rax, %rbx
leaq 0x7f34f(%rip), %r14 # 0xdc900
movq %rax, (%r14)
movl $0x140000, %edi # imm = 0x140000
callq 0x33b0
leaq 0x7f343(%rip), %r15 # 0xdc908
movq %rax, (%r15)
testq %rbx, %rbx
jne 0x5d5db
leaq 0x5bd73(%rip), %rdi # 0xb9347
xorl %esi, %esi
callq 0x18f07
cmpq $0x0, (%r15)
jne 0x5d5ef
leaq 0x5bd78(%rip), %rdi # 0xb9360
xorl %esi, %esi
callq 0x18f07
movq (%r14), %rax
leaq 0x7f2bf(%rip), %rbx # 0xdc8b8
movq %rax, (%rbx)
movq (%r15), %rax
leaq 0x7f30a(%rip), %r15 # 0xdc910
movq %rax, (%r15)
xorl %eax, %eax
leaq 0x79b62(%rip), %rcx # 0xd7174
xorl %edx, %edx
xorl %esi, %esi
movq (%rbx), %rdi
movq %rax, 0x1e0(%rdi,%rsi)
movq (%rbx), %rdi
movq %rax, 0x1e8(%rdi,%rsi)
movq (%rbx), %rdi
movq %rax, 0x2a0(%rdi,%rsi)
movq (%rbx), %rdi
movq %rax, 0x2c0(%rdi,%rsi)
movq (%rbx), %rdi
movl %eax, 0x2c8(%rdi,%rsi)
movl %eax, 0x340(%rdi,%rsi)
movl %eax, 0x8(%rdi,%rsi)
movl (%rcx), %r8d
movl %r8d, 0x210(%rdi,%rsi)
movl %eax, 0x364(%rdi,%rsi)
movq (%r15), %rdi
movq %rax, 0x10(%rdi,%rdx)
movq (%r15), %rdi
movq %rax, 0x18(%rdi,%rdx)
movq (%r15), %rdi
movl %eax, 0x8(%rdi,%rdx)
addq $0x368, %rsi # imm = 0x368
addq $0x28, %rdx
cmpq $0x1b40000, %rsi # imm = 0x1B40000
jne 0x5d616
movq $0x8000, 0x8(%rsp) # imm = 0x8000
pxor %xmm0, %xmm0
leaq 0x7f270(%rip), %rax # 0xdc918
movdqu %xmm0, (%rax)
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, 0x20(%rax)
movdqu %xmm0, 0x30(%rax)
movdqu %xmm0, 0x40(%rax)
movdqu %xmm0, 0x50(%rax)
movdqu %xmm0, 0x60(%rax)
movdqu %xmm0, 0x70(%rax)
xorl %eax, %eax
callq 0x99bc0
xorl %eax, %eax
callq 0x5a0c3
cltq
leaq 0x7f2b2(%rip), %r12 # 0xdc998
movq %rax, (%r12)
leaq 0x30(,%rax,8), %rdi
callq 0x33b0
leaq 0x7f2a2(%rip), %rcx # 0xdc9a0
movq %rax, (%rcx)
xorl %eax, %eax
callq 0x5a04a
movslq %eax, %rsi
leaq 0x7f296(%rip), %rax # 0xdc9a8
movq %rsi, (%rax)
testl %esi, %esi
js 0x5d71f
cmpq %rsi, (%r12)
jge 0x5d72b
leaq 0x5bc5a(%rip), %rdi # 0xb9380
callq 0x18f07
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x5a04a
xorl %eax, %eax
callq 0x69902
leaq 0x79a25(%rip), %rax # 0xd7168
cmpl $0x0, (%rax)
jle 0x5d76a
movq (%rbx), %rcx
addq $0x8, %rcx
xorl %r14d, %r14d
movl $0x0, (%rcx)
incq %r14
movslq (%rax), %rdx
addq $0x368, %rcx # imm = 0x368
cmpq %rdx, %r14
jl 0x5d752
movq %r14, 0x8(%rsp)
cmpl $0x0, (%rax)
jle 0x5d797
movq (%rbx), %rdx
addq $0xc, %rdx
xorl %ecx, %ecx
movl $0x0, (%rdx)
incq %rcx
movslq (%rax), %rsi
addq $0x368, %rdx # imm = 0x368
cmpq %rsi, %rcx
jl 0x5d77d
jmp 0x5d799
xorl %ecx, %ecx
movq %rcx, 0x8(%rsp)
movq (%r12), %r14
leaq (,%r14,8), %rdi
callq 0x33b0
movq (%r15), %rcx
movq %rax, 0x10(%rcx)
leaq (%rax,%r14,4), %rbx
movq %rbx, 0x18(%rcx)
testq %r14, %r14
jle 0x5d7dd
leaq (,%r14,4), %rdx
movq %rax, %rdi
movl $0xff, %esi
callq 0x3170
movq %r14, %rax
jmp 0x5d7df
xorl %eax, %eax
movq %rax, 0x8(%rsp)
testq %r14, %r14
jle 0x5d800
leaq (,%r14,4), %rdx
movq %rbx, %rdi
movl $0xff, %esi
callq 0x3170
jmp 0x5d803
xorl %r14d, %r14d
movq %r14, 0x8(%rsp)
xorl %eax, %eax
callq 0x1b3bb
movq %rax, %r14
movq %rax, %rdi
callq 0x1b3d3
movq %rax, %rbx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1b3e2
movq %rax, 0x10(%rsp)
movq (%r15), %rdx
movabsq $-0xffffffff, %rcx # imm = 0xFFFFFFFF00000001
movq %rcx, 0x8(%rdx)
movl %ebx, 0x4(%rdx)
movl $0x1, (%rdx)
testq %rbx, %rbx
jle 0x5d86d
movq %rax, %rcx
shlq $0x2, %rcx
addq 0x10(%rdx), %rcx
movq 0x18(%rdx), %rdx
xorl %esi, %esi
movl %esi, (%rcx,%rsi,4)
leal (%rax,%rsi), %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rbx
jne 0x5d85c
leaq 0x8(%rsp), %r15
movq %rbx, (%r15)
leaq 0x798f0(%rip), %rbp # 0xd716c
movslq (%rbp), %r12
movl $0x3f2, %edi # imm = 0x3F2
callq 0x99e0
leaq 0x5ab54(%rip), %r8 # 0xb83e5
movl $0x1, %ecx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x7807b
leaq 0x10(%rsp), %r12
movq %rbx, (%r12)
movslq (%rbp), %r13
movl $0x3f2, %edi # imm = 0x3F2
callq 0x99e0
leaq 0x5ab1c(%rip), %r8 # 0xb83de
movl $0x1, %ecx
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x7807b
movq (%r15), %rax
cmpq (%r12), %rax
jne 0x5d9de
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1b3c7
movq %rax, %r15
leaq (,%rax,8), %rdi
callq 0x33b0
movq %rax, %r12
leaq 0x7f0a3(%rip), %rax # 0xdc9a8
movq (%rax), %r13
movq %r14, %rdi
xorl %esi, %esi
callq 0x1b3e2
testq %r15, %r15
jle 0x5d9bd
leaq 0x1(%r15), %rcx
andq $-0x2, %rcx
movq %r15, %rdx
decq %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
subq %rax, %r13
leaq (%rbx,%rbx), %rax
movdqa 0x53b7e(%rip), %xmm1 # 0xb14c0
xorl %edx, %edx
movdqa 0x53b44(%rip), %xmm2 # 0xb1490
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x553f4(%rip), %xmm4 # 0xb2d50
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x5d992
movq %r13, (%r12,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x5d9aa
leaq (%rbx,%r13), %rsi
movq %rsi, 0x8(%r12,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
addq %rax, %r13
cmpq %rdx, %rcx
jne 0x5d95c
movq %r15, %rbp
movq %rbp, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5dadd
movq %rax, 0x7efdc(%rip) # 0xdc9b0
movq %r12, %rdi
callq 0x3330
jmp 0x5d9e9
movslq (%rbp), %rax
movq %rax, 0x7efc7(%rip) # 0xdc9b0
leaq 0x7efa8(%rip), %rax # 0xdc998
movq (%rax), %rdi
shlq $0x3, %rdi
callq 0x33b0
leaq 0x7efb5(%rip), %rbx # 0xdc9b8
movq %rax, (%rbx)
testq %rax, %rax
leaq 0x7ef98(%rip), %r14 # 0xdc9a8
jne 0x5da21
movslq (%r14), %rsi
leaq 0x5b99b(%rip), %rdi # 0xb93b7
callq 0x18f07
movq (%rbx), %rdi
movl $0x38, %esi
callq 0x58fc9
testl %eax, %eax
je 0x5da41
movq (%r14), %rsi
leaq 0x5b9a9(%rip), %rdi # 0xb93e5
callq 0x18f07
movq (%rbx), %rax
movq (%r14), %rsi
cmpq $0x0, (%rax,%rsi,8)
jne 0x5da5a
leaq 0x5b9c5(%rip), %rdi # 0xb941a
callq 0x18f07
movl $0x4, %edi
callq 0x58fd3
leaq 0x7ef55(%rip), %rcx # 0xdc9c0
movq %rax, (%rcx)
movq (%rbx), %rax
movq (%r14), %rcx
movq (%rax,%rcx,8), %rax
pxor %xmm0, %xmm0
movdqu %xmm0, (%rax)
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movq $0xe, 0x8(%rsp)
leaq -0x4bbb(%rip), %rdi # 0x58ee7
callq 0x57094
movb $0x1, 0x7ee42(%rip) # 0xdc8f0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x77fe5
leaq 0x7ef09(%rip), %rsi # 0xdc9c8
movq %rax, %rdi
callq 0x33c0
xorl %eax, %eax
callq 0x3a3c4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_initialize_comm | int pnga_initialize_comm(MPI_Comm comm)
{
/**
* Initialize ARMCI first using communicator and then initialize GA using
* conventional initialization program. The conventional initialization code
* should recognize that ARMCI has already been initialized
*/
int ret = ARMCI_Init_mpi_comm(comm);
if (ret) {
pnga_initialize();
}
return ret;
} | pushq %rbx
callq 0x58fb8
movl %eax, %ebx
testl %eax, %eax
je 0x5dd9d
callq 0x5d49f
movl %ebx, %eax
popq %rbx
retq
| /GlobalArrays[P]ga/global/src/base.c |
gai_print_subscript | void gai_print_subscript(char *pre,int ndim, Integer subscript[], char* post)
{
int i;
printf("%s [",pre);
for(i=0;i<ndim;i++){
printf("%ld",(long)subscript[i]);
if(i==ndim-1)printf("] %s",post);
else printf(",");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rsi
leaq 0x59a5b(%rip), %rdi # 0xb9440
xorl %eax, %eax
callq 0x3050
testl %r15d, %r15d
jle 0x5fa3a
leal -0x1(%r15), %r13d
movl %r15d, %ebp
leaq 0x5754d(%rip), %r15 # 0xb6f4c
xorl %r12d, %r12d
movq (%r14,%r12,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x3050
cmpq %r12, %r13
jne 0x5fa28
leaq 0x53994(%rip), %rdi # 0xb33b0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3050
jmp 0x5fa32
movl $0x2c, %edi
callq 0x33f0
incq %r12
cmpq %r12, %rbp
jne 0x5fa02
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_set_chunk | void pnga_set_chunk(Integer g_a, Integer *chunk)
{
Integer i;
Integer ga_handle = g_a + GA_OFFSET;
if (GA[ga_handle].actv == 1)
pnga_error("Cannot set chunk on array that has been allocated",0);
if (GA[ga_handle].ndim < 1)
pnga_error("Dimensions must be set before chunk array is specified",0);
if (chunk) {
for (i=0; i<GA[ga_handle].ndim; i++) {
GA[ga_handle].chunk[i] = (C_Integer)chunk[i];
}
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7c396(%rip), %r15 # 0xdc8b8
movq (%r15), %rax
imulq $0x368, %rdi, %rcx # imm = 0x368
addq $0x3e8, %r14 # imm = 0x3E8
cmpl $0x1, 0xd4e48(%rcx,%rax)
jne 0x6054b
leaq 0x590ad(%rip), %rdi # 0xb95f1
xorl %esi, %esi
callq 0x18f07
movq (%r15), %rax
imulq $0x368, %r14, %r14 # imm = 0x368
cmpw $0x0, (%rax,%r14)
jg 0x6056b
leaq 0x590bf(%rip), %rdi # 0xb9623
xorl %esi, %esi
callq 0x18f07
testq %rbx, %rbx
je 0x60593
movq (%r15), %rax
movswq (%rax,%r14), %rcx
testq %rcx, %rcx
jle 0x60593
addq %r14, %rax
xorl %edx, %edx
movq (%rbx,%rdx,8), %rsi
movq %rsi, 0x68(%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x60582
popq %rbx
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_set_property | void pnga_set_property(Integer g_a, char* property) {
Integer ga_handle = g_a + GA_OFFSET;
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous sync masking*/
pnga_pgroup_sync(GA[ga_handle].p_handle);
/* Check to see if property conflicts with properties already set on the
* global array. This check may need more refinement as additional properties
* are added. */
if (GA[ga_handle].property != NO_PROPERTY) {
pnga_error("Cannot set property on an array that already has property set",0);
}
if (strcmp(property,"read_only")==0) {
/* TODO: copy global array to new configuration */
int i, d, ndim, btot, chk;
Integer nprocs, nodeid, origin_id, dflt_grp, handle, maplen;
Integer nelem, mem_size, status, grp_me, g_tmp, me_local;
Integer *list;
Integer blk[MAXDIM], dims[MAXDIM], pe[MAXDIM], chunk[MAXDIM];
Integer lo[MAXDIM], hi[MAXDIM], ld[MAXDIM];
Integer *pmap[MAXDIM], *map;
char *buf;
if (GA[ga_handle].distr_type != REGULAR) {
pnga_error("Block-cyclic arrays not supported for READ_ONLY",0);
}
if (GA[ga_handle].p_handle != pnga_pgroup_get_world()) {
pnga_error("Arrays on subgroups not supported for READ_ONLY",0);
}
ndim = (int)GA[ga_handle].ndim;
btot = 0;
for (i=0; i<ndim; i++) {
GA[ga_handle].old_nblock[i] = GA[ga_handle].nblock[i];
GA[ga_handle].old_lo[i] = GA[ga_handle].lo[i];
GA[ga_handle].old_chunk[i] = GA[ga_handle].chunk[i];
btot += GA[ga_handle].nblock[i];
}
GA[ga_handle].old_mapc = (Integer*)malloc((btot+1)*sizeof(Integer));
for (i=0; i<btot+1; i++) {
GA[ga_handle].old_mapc[i] = GA[ga_handle].mapc[i];
}
/* Make a temporary copy of GA */
g_tmp = pnga_create_handle();
pnga_set_data(g_tmp,ndim,GA[ga_handle].dims,GA[ga_handle].type);
pnga_set_pgroup(g_tmp,GA[ga_handle].p_handle);
if (!pnga_allocate(g_tmp)) {
pnga_error("Failed to allocate temporary array",0);
}
pnga_copy(g_a, g_tmp);
/* Create a group containing all the processors on this node */
GA[ga_handle].old_handle = GA[ga_handle].p_handle;
nodeid = pnga_cluster_nodeid();
nprocs = pnga_cluster_nprocs(nodeid);
origin_id = pnga_cluster_procid(nodeid,0);
dflt_grp = pnga_pgroup_get_default();
pnga_pgroup_set_default(pnga_pgroup_get_world());
list = (Integer*)malloc(nprocs*sizeof(Integer));
for (i=0; i<nprocs; i++) {
list[i] = origin_id+i;
}
handle = pnga_pgroup_create(list, nprocs);
free(list);
GA[ga_handle].p_handle = handle;
GA[ga_handle].property = READ_ONLY;
/* Ignore hints on data distribution (chunk) and just go with default
* distribution on the node, except if chunk dimension is same as array
* dimension (no partitioning on that axis) */
for (i=0; i<ndim; i++) {
/* eliminate dimension=1 from analysis, otherwise set blk to -1*/
if (GA[ga_handle].chunk[i] == GA[ga_handle].dims[i]) {
chunk[i] = GA[ga_handle].chunk[i];
} else {
chunk[i] = -1;
}
dims[i] = GA[ga_handle].dims[i];
}
if (chunk[0] != 0)
for (d=0; d<ndim; d++) blk[d]=(Integer)GA_MIN(chunk[d],dims[d]);
else
for (d=0; d<ndim; d++) blk[d]=-1;
for (d=0; d<ndim; d++) if (dims[d]==1) blk[d]=1;
ddb_h2(ndim, dims, PGRP_LIST[handle].map_nproc,0.0,(Integer)0,blk,pe);
for(d=0, map=mapALL; d< ndim; d++){
Integer nblock;
Integer pcut; /* # procs that get full blk[] elements; the rest gets less*/
int p;
pmap[d] = map;
/* RJH ... don't leave some nodes without data if possible
* but respect the users block size */
if (chunk[d] > 1) {
Integer ddim = ((dims[d]-1)/GA_MIN(chunk[d],dims[d]) + 1);
pcut = (ddim -(blk[d]-1)*pe[d]) ;
} else {
pcut = (dims[d]-(blk[d]-1)*pe[d]) ;
}
for (nblock=i=p=0; (p<pe[d]) && (i<dims[d]); p++, nblock++) {
Integer b = blk[d];
if (p >= pcut)
b = b-1;
map[nblock] = i+1;
if (chunk[d]>1) b *= GA_MIN(chunk[d],dims[d]);
i += b;
}
pe[d] = GA_MIN(pe[d],nblock);
map += pe[d];
}
maplen = 0;
for( i = 0; i< ndim; i++){
GA[ga_handle].nblock[i] = pe[i];
maplen += pe[i];
}
free(GA[ga_handle].mapc);
GA[ga_handle].mapc = (Integer*)malloc((maplen+1)*sizeof(Integer));
for(i = 0; i< maplen; i++) {
GA[ga_handle].mapc[i] = (C_Integer)mapALL[i];
}
GA[ga_handle].mapc[maplen] = -1;
/* Set remaining paramters and determine memory size if regular data
* distribution is being used */
for( i = 0; i< ndim; i++){
GA[ga_handle].scale[i] = (double)GA[ga_handle].nblock[i]
/ (double)GA[ga_handle].dims[i];
}
/*** determine which portion of the array I am supposed
* to hold ***/
pnga_distribution(g_a, GAme, GA[ga_handle].lo, hi);
chk = 1;
for( i = 0, nelem=1; i< ndim; i++){
if (hi[i]-(Integer)GA[ga_handle].lo[i]+1 <= 0) chk = 0;
nelem *= (hi[i]-(Integer)GA[ga_handle].lo[i]+1);
}
mem_size = nelem * GA[ga_handle].elemsize;
if (!chk) mem_size = 0;
grp_me = pnga_pgroup_nodeid(handle);
/* Clean up old memory first */
#ifndef AVOID_MA_STORAGE
if(gai_uses_shm((int)handle)){
#endif
/* make sure that we free original (before address allignment)
* pointer */
#ifdef MSG_COMMS_MPI
if (GA[ga_handle].old_handle > 0){
ARMCI_Free_group(
GA[ga_handle].ptr[pnga_pgroup_nodeid(GA[ga_handle].old_handle)]
- GA[ga_handle].id,
&PGRP_LIST[GA[ga_handle].old_handle].group);
}
else
#endif
{
ARMCI_Free(
GA[ga_handle].ptr[pnga_pgroup_nodeid(GA[ga_handle].old_handle)]
- GA[ga_handle].id);
}
#ifndef AVOID_MA_STORAGE
}else{
if(GA[ga_handle].id != INVALID_MA_HANDLE) MA_free_heap(GA[ga_handle].id);
}
#endif
if(GA_memory_limited) GA_total_memory += GA[ga_handle].size;
GAstat.curmem -= GA[ga_handle].size;
/* if requested, enforce limits on memory consumption */
if(GA_memory_limited) GA_total_memory -= mem_size;
GAstat.curmem += mem_size;
/* check if everybody has enough memory left */
if(GA_memory_limited){
status = (GA_total_memory >= 0) ? 1 : 0;
pnga_pgroup_gop(handle,pnga_type_f2c(MT_F_INT), &status, 1, "&&");
} else status = 1;
/* allocate memory */
if (status) {
/* Allocate new memory */
if (GA[ga_handle].mem_dev_set) {
status = !gai_get_devmem(GA[ga_handle].name, GA[ga_handle].ptr,mem_size,
GA[ga_handle].type, &GA[ga_handle].id, handle,
GA[ga_handle].mem_dev_set,GA[ga_handle].mem_dev);
} else {
status = !gai_getmem(GA[ga_handle].name, GA[ga_handle].ptr,mem_size,
GA[ga_handle].type, &GA[ga_handle].id, handle);
}
} else {
GA[ga_handle].ptr[grp_me]=NULL;
}
GA[ga_handle].size = (C_Long)mem_size;
if (!status) {
pnga_error("Memory failure when unsetting READ_ONLY",0);
}
/* Copy data from copy of old GA to new GA and then get rid of copy*/
pnga_distribution(g_a,GAme,lo,hi);
chk = 1;
nelem = 1;
for (i=0; i<ndim; i++) {
/*
GA[ga_handle].chunk[i] = ((C_Integer)hi[i]-GA[ga_handle].lo[i]+1);
*/
ld[i] = hi[i] - lo[i] + 1;
nelem *= ld[i];
if (hi[i] < lo[i]) chk = 0;
}
if (chk) {
#if 1
pnga_get(g_tmp,lo,hi,GA[ga_handle].ptr[grp_me],ld);
#else
/* MPI RMA does not allow you to use memory assigned to one window as
* local buffer for another buffer. Create a local buffer to get around
* this problem */
buf = (char*)malloc(nelem*GA[ga_handle].elemsize);
pnga_get(g_tmp,lo,hi,buf,ld);
memcpy(GA[ga_handle].ptr[grp_me],buf,nelem*GA[ga_handle].elemsize);
free(buf);
#endif
}
pnga_destroy(g_tmp);
} else if (strcmp(property, "read_cache") == 0) {
GA[ga_handle].property = READ_CACHE;
GA[ga_handle].cache_head = NULL; /* (cache_struct_t *)malloc(sizeof(cache_struct_t)) */
} else {
pnga_error("Trying to set unknown property",0);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x3e8(%rdi), %rax
leaq 0x75bd4(%rip), %rdx # 0xd7160
movl $0x1, %ecx
movl %ecx, (%rdx)
leaq 0x75bca(%rip), %r12 # 0xd7164
movl %ecx, (%r12)
leaq 0x7b313(%rip), %r15 # 0xdc8b8
movq (%r15), %rcx
imulq $0x368, %rax, %rbx # imm = 0x368
movslq 0x210(%rcx,%rbx), %rdi
callq 0x6979c
movq (%r15), %rax
cmpl $0x0, 0x2c8(%rax,%rbx)
je 0x615d7
leaq 0x58647(%rip), %rdi # 0xb9c17
xorl %esi, %esi
callq 0x18f07
leaq 0x58677(%rip), %rsi # 0xb9c55
movq %r14, %rdi
callq 0x3400
testl %eax, %eax
je 0x61620
leaq 0x58719(%rip), %rsi # 0xb9d0a
movq %r14, %rdi
callq 0x3400
testl %eax, %eax
je 0x616b5
leaq 0x5870d(%rip), %rdi # 0xb9d15
xorl %esi, %esi
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x18f07
movq (%r15), %rax
cmpl $0x0, 0x224(%rax,%rbx)
je 0x6163b
leaq 0x5862b(%rip), %rdi # 0xb9c5f
xorl %esi, %esi
callq 0x18f07
movq (%r15), %rax
cmpl $-0x1, 0x210(%rax,%rbx)
je 0x61656
leaq 0x58640(%rip), %rdi # 0xb9c8f
xorl %esi, %esi
callq 0x18f07
movq (%r15), %r13
movswl (%r13,%rbx), %ecx
movl %ecx, %r14d
movq %rcx, (%rsp)
testl %ecx, %ecx
movq %rbp, 0x10(%rsp)
jle 0x616d4
imulq $0x368, %rbp, %rax # imm = 0x368
addq %r13, %rax
xorl %ecx, %ecx
xorl %r15d, %r15d
movl 0xd4ee0(%rax,%rcx,4), %edx
movl %edx, 0xd5118(%rax,%rcx,4)
movl 0xd4fb0(%rax,%rcx,8), %esi
movl %esi, 0xd5138(%rax,%rcx,4)
movl 0xd4ea8(%rax,%rcx,8), %esi
movl %esi, 0xd5154(%rax,%rcx,4)
addl %edx, %r15d
incq %rcx
cmpq %rcx, %r14
jne 0x6167e
jmp 0x616d7
movq (%r15), %rax
movl $0x2, 0x2c8(%rax,%rbx)
movq $0x0, 0x338(%rax,%rbx)
jmp 0x61ede
xorl %r15d, %r15d
movslq (%rsp), %rax
movq %rax, 0x8(%rsp)
movslq %r15d, %rbp
leaq 0x8(,%rbp,8), %rdi
callq 0x33b0
movq %rax, 0x2d0(%r13,%rbx)
testl %ebp, %ebp
leaq 0x7b1b7(%rip), %r13 # 0xdc8b8
js 0x6172c
movq (%r13), %rcx
movq 0x1e8(%rcx,%rbx), %rax
movq 0x2d0(%rcx,%rbx), %rcx
incl %r15d
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r15
jne 0x6171c
callq 0x6029f
movq %rax, %rbp
movq (%r13), %rax
leaq (%rax,%rbx), %rdx
addq $0x30, %rdx
movslq -0x2c(%rdx), %rcx
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
callq 0x603b3
movq (%r13), %rax
movslq 0x210(%rax,%rbx), %rsi
movq %rbp, %rdi
callq 0x60691
movq %rbp, %rdi
callq 0x61ef0
testq %rax, %rax
movq 0x10(%rsp), %r15
jne 0x61785
leaq 0x58541(%rip), %rdi # 0xb9cbf
xorl %esi, %esi
callq 0x18f07
movq %r15, %rdi
movq %rbp, 0x28(%rsp)
movq %rbp, %rsi
callq 0x108fe
movq (%r13), %rax
movl 0x210(%rax,%rbx), %ecx
movl %ecx, 0x2f4(%rax,%rbx)
xorl %eax, %eax
callq 0x1b3bb
movq %rax, %r13
movq %rax, %rdi
callq 0x1b3d3
movq %rax, %r15
movq %r13, %rdi
xorl %esi, %esi
callq 0x1b3e2
movq %rax, %r13
movl $0x1, %eax
leaq 0x7598b(%rip), %rcx # 0xd7160
movl %eax, (%rcx)
movl %eax, (%r12)
leaq 0x7598e(%rip), %rax # 0xd7170
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
leaq 0x70(%rsp), %rbp
movq %rbp, %rdi
callq 0x590e8
movq %rbp, %rdi
callq 0x590d0
leaq (,%r15,8), %rdi
callq 0x33b0
movq %rax, %rbp
testq %r15, %r15
jle 0x618b4
leaq 0x1(%r15), %rax
andq $-0x2, %rax
movq %r15, %rcx
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
leaq 0x1(%r13), %rcx
movdqa 0x4fc86(%rip), %xmm1 # 0xb14c0
xorl %edx, %edx
movdqa 0x4fc4c(%rip), %xmm2 # 0xb1490
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x514fc(%rip), %xmm4 # 0xb2d50
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x6188f
leaq (%rdx,%r13), %rsi
movq %rsi, (%rbp,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x618a7
leaq (%rcx,%rdx), %rsi
movq %rsi, 0x8(%rbp,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
cmpq %rdx, %rax
jne 0x61854
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5dadd
movq %rax, %r15
movq %rbp, %rdi
callq 0x3330
leaq 0x7afe7(%rip), %rbp # 0xdc8b8
movq (%rbp), %rax
movl %r15d, 0x210(%rax,%rbx)
movl $0x1, 0x2c8(%rax,%rbx)
cmpw $0x0, 0x8(%rsp)
jle 0x61924
addq %rbx, %rax
xorl %ecx, %ecx
movq $-0x1, %rdx
movq 0x68(%rax,%rcx,8), %rsi
cmpq 0x30(%rax,%rcx,8), %rsi
cmovneq %rdx, %rsi
movq %rsi, 0x130(%rsp,%rcx,8)
movq 0x30(%rax,%rcx,8), %rsi
movq %rsi, 0x30(%rsp,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x618fc
cmpq $0x0, 0x130(%rsp)
je 0x6195b
cmpw $0x0, (%rsp)
jle 0x6197d
xorl %eax, %eax
movq 0x130(%rsp,%rax,8), %rcx
movq 0x30(%rsp,%rax,8), %rdx
cmpq %rdx, %rcx
cmovlq %rcx, %rdx
movq %rdx, 0x70(%rsp,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x61938
jmp 0x6197d
cmpw $0x0, 0x8(%rsp)
jle 0x6197d
movq (%rsp), %rax
leal (,%rax,8), %edx
leaq 0x70(%rsp), %rdi
movl $0xff, %esi
callq 0x3170
cmpw $0x0, (%rsp)
jle 0x6199f
xorl %eax, %eax
cmpq $0x1, 0x30(%rsp,%rax,8)
jne 0x61997
movq $0x1, 0x70(%rsp,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x61986
leaq 0x7af6a(%rip), %r13 # 0xdc910
movq (%r13), %rax
leaq (%r15,%r15,4), %rcx
movslq 0x4(%rax,%rcx,8), %rdx
leaq 0x30(%rsp), %rsi
leaq 0x70(%rsp), %r8
leaq 0xb0(%rsp), %r9
pxor %xmm0, %xmm0
movq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x97790
testw %r12w, %r12w
jle 0x61ad2
leaq 0x7afb7(%rip), %rax # 0xdc9a0
movq (%rax), %rcx
xorl %esi, %esi
movq 0x130(%rsp,%rsi,8), %rdi
movq 0x30(%rsp,%rsi,8), %r8
cmpq $0x2, %rdi
jl 0x61a2d
leaq -0x1(%r8), %rax
cmpq %r8, %rdi
cmovlq %rdi, %r8
cqto
idivq %r8
movl $0x1, %edx
subq 0x70(%rsp,%rsi,8), %rdx
imulq 0xb0(%rsp,%rsi,8), %rdx
leaq (%rax,%rdx), %r8
incq %r8
jmp 0x61a41
movq 0x70(%rsp,%rsi,8), %rax
decq %rax
imulq 0xb0(%rsp,%rsi,8), %rax
subq %rax, %r8
movq 0xb0(%rsp,%rsi,8), %r9
testq %r9, %r9
jle 0x61ab0
cmpq $0x0, 0x30(%rsp,%rsi,8)
jle 0x61ab0
xorl %eax, %eax
xorl %edx, %edx
movq 0x70(%rsp,%rsi,8), %r10
xorl %r9d, %r9d
cmpq %rax, %r8
setle %r9b
subq %r9, %r10
leal 0x1(%rdx), %r9d
movslq %r9d, %r9
movq %r9, (%rcx,%rax,8)
cmpq $0x2, %rdi
jl 0x61a8d
movq 0x30(%rsp,%rsi,8), %r9
cmpq %r9, %rdi
cmovlq %rdi, %r9
imulq %r9, %r10
leaq 0x1(%rax), %r11
movq 0xb0(%rsp,%rsi,8), %r9
cmpq %r11, %r9
jle 0x61ab3
addl %r10d, %edx
movslq %edx, %r10
incq %rax
cmpq %r10, 0x30(%rsp,%rsi,8)
jg 0x61a5a
jmp 0x61ab3
xorl %r11d, %r11d
cmpq %r11, %r9
cmovlq %r9, %r11
movq %r11, 0xb0(%rsp,%rsi,8)
leaq (%rcx,%r11,8), %rcx
incq %rsi
cmpq %r14, %rsi
jne 0x619ee
cmpw $0x0, (%rsp)
jle 0x61b0c
movq (%rbp), %rax
imulq $0x368, 0x10(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
addq $0xd4ee0, %rax # imm = 0xD4EE0
xorl %ecx, %ecx
xorl %r12d, %r12d
movq 0xb0(%rsp,%rcx,8), %rdx
movl %edx, (%rax,%rcx,4)
addq %rdx, %r12
incq %rcx
cmpq %rcx, %r14
jne 0x61af4
jmp 0x61b0f
xorl %r12d, %r12d
movq (%rbp), %rax
movq 0x1e8(%rax,%rbx), %rdi
callq 0x3330
leaq 0x8(,%r12,8), %rdi
callq 0x33b0
movq (%rbp), %rcx
movq %rax, 0x1e8(%rcx,%rbx)
testq %r12, %r12
jle 0x61b66
leaq 0x7ae5b(%rip), %rax # 0xdc9a0
movq (%rax), %rax
movq (%rbp), %rcx
movq 0x1e8(%rcx,%rbx), %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x61b56
movq (%rbp), %rax
movq 0x1e8(%rax,%rbx), %rcx
movq $-0x1, (%rcx,%r12,8)
cmpw $0x0, 0x8(%rsp)
jle 0x61bbe
imulq $0x368, 0x10(%rsp), %rcx # imm = 0x368
addq %rax, %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
cvtsi2sdl 0xd4ee0(%rcx,%rdx,4), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0xd4e70(%rcx,%rdx,8), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0xd4fe8(%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0x61b90
leaq 0x7ade3(%rip), %rbp # 0xdc9a8
movq (%rbp), %rsi
leaq (%rax,%rbx), %rdx
addq $0x170, %rdx # imm = 0x170
leaq 0xf0(%rsp), %rcx
movq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x5f51f
xorl %ecx, %ecx
cmpw $0x0, 0x8(%rsp)
jle 0x61c3e
leaq 0x7acbe(%rip), %rax # 0xdc8b8
movq (%rax), %rax
imulq $0x368, %r12, %rdx # imm = 0x368
addq %rdx, %rax
addq $0xd4fb0, %rax # imm = 0xD4FB0
movl $0x1, %edx
movl $0x1, %esi
xorl %edi, %edi
movq 0xf0(%rsp,%rdi,8), %r8
subq (%rax,%rdi,8), %r8
cmovll %ecx, %esi
incq %r8
imulq %r8, %rdx
incq %rdi
cmpq %rdi, %r14
jne 0x61c19
testl %esi, %esi
sete %cl
jmp 0x61c43
movl $0x1, %edx
leaq 0x7ac6e(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movslq 0x18(%rax,%rbx), %rsi
imulq %rdx, %rsi
xorl %r12d, %r12d
testb %cl, %cl
cmoveq %rsi, %r12
testq %r15, %r15
movq %r15, 0x20(%rsp)
js 0x61c86
movq (%r13), %rcx
movslq %r15d, %rdx
leaq (%rdx,%rdx,4), %rdx
movq 0x10(%rcx,%rdx,8), %rcx
movq %rbp, %r15
movq (%rbp), %rdx
movslq (%rcx,%rdx,4), %rbp
jmp 0x61c8d
movq %rbp, %r15
movq (%rbp), %rbp
movslq 0x2f4(%rax,%rbx), %rdx
movq 0x1e0(%rax,%rbx), %rcx
testq %rdx, %rdx
jle 0x61ccf
addq %rbx, %rax
movq (%r13), %rsi
leaq (%rdx,%rdx,4), %rdx
leaq (%rsi,%rdx,8), %rsi
addq $0x20, %rsi
movq -0x10(%rsi), %rdx
movq (%r15), %rdi
movslq (%rdx,%rdi,4), %rdx
movq (%rcx,%rdx,8), %rdi
subq 0x28(%rax), %rdi
callq 0x5820c
jmp 0x61cfa
testl %edx, %edx
js 0x61ce9
movq (%r13), %rsi
leaq (%rdx,%rdx,4), %rdx
movq 0x10(%rsi,%rdx,8), %rdx
movq (%r15), %rsi
movslq (%rdx,%rsi,4), %rdx
jmp 0x61cec
movq (%r15), %rdx
movq (%rcx,%rdx,8), %rdi
subq 0x28(%rax,%rbx), %rdi
callq 0x58f7a
movb 0x7abf8(%rip), %dl # 0xdc8f8
cmpb $0x1, %dl
jne 0x61d1b
leaq 0x7abac(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq 0x10(%rax,%rbx), %rax
addq %rax, 0x7545d(%rip) # 0xd7178
leaq 0x7ab96(%rip), %rax # 0xdc8b8
movq (%rax), %rsi
leaq 0x7abec(%rip), %rax # 0xdc918
movq 0x48(%rax), %rcx
subq 0x10(%rsi,%rbx), %rcx
movq %rcx, 0x48(%rax)
testb %dl, %dl
je 0x61d8d
movq 0x75434(%rip), %rdx # 0xd7178
subq %r12, %rdx
movq %rdx, 0x7542a(%rip) # 0xd7178
addq %r12, %rcx
movq %rcx, 0x48(%rax)
notq %rdx
shrq $0x3f, %rdx
leaq 0x18(%rsp), %r13
movq %rdx, (%r13)
movl $0x3f2, %edi # imm = 0x3F2
callq 0x99e0
leaq 0x4fb59(%rip), %r8 # 0xb18cf
movl $0x1, %ecx
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x7807b
jmp 0x61d9d
addq %r12, %rcx
movq %rcx, 0x48(%rax)
movq $0x1, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
leaq 0x7ab0e(%rip), %rax # 0xdc8b8
movq (%rax), %rax
je 0x61deb
leaq (%rax,%rbx), %r8
addq $0x28, %r8
movl 0x318(%r8), %edi
movq 0x1b8(%r8), %rsi
movl -0x24(%r8), %ecx
testl %edi, %edi
je 0x61dfd
addq %rbx, %rax
addq $0x344, %rax # imm = 0x344
movq %r12, %rdx
movq 0x20(%rsp), %r9
pushq %rax
pushq %rdi
callq 0x63016
addq $0x10, %rsp
jmp 0x61e12
movq 0x1e0(%rax,%rbx), %rax
movq $0x0, (%rax,%rbp,8)
jmp 0x61e1e
movq %rsi, %rdi
movq %r12, %rsi
movl %ecx, %edx
movq %r8, %rcx
movq 0x20(%rsp), %r8
callq 0x64ec9
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq %rcx, 0x18(%rsp)
leaq 0x7aa93(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq %r12, 0x10(%rax,%rbx)
cmpq $0x0, 0x18(%rsp)
jne 0x61e43
leaq 0x57ea6(%rip), %rdi # 0xb9ce2
xorl %esi, %esi
callq 0x18f07
movq (%r15), %rsi
leaq 0x170(%rsp), %rdx
leaq 0xf0(%rsp), %rcx
movq 0x10(%rsp), %rdi
callq 0x5f51f
cmpw $0x0, (%rsp)
leaq 0x7aa4c(%rip), %rdi # 0xdc8b8
movq 0x28(%rsp), %r15
jle 0x61ea7
movl $0x1, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movq 0xf0(%rsp,%rdx,8), %rsi
subq 0x170(%rsp,%rdx,8), %rsi
leaq 0x1(%rsi), %rsi
movq %rsi, 0x1b0(%rsp,%rdx,8)
cmovll %ecx, %eax
incq %rdx
cmpq %rdx, %r14
jne 0x61e7c
testl %eax, %eax
je 0x61ed6
movq (%rdi), %rax
movq 0x1e0(%rax,%rbx), %rax
movq (%rax,%rbp,8), %rcx
leaq 0x170(%rsp), %rsi
leaq 0xf0(%rsp), %rdx
leaq 0x1b0(%rsp), %r8
movq %r15, %rdi
callq 0x6abb1
movq %r15, %rdi
callq 0x63281
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/base.c |
GA_Getmem | void *GA_Getmem(int type, int nelem, int grp_id)
{
char **ptr_arr=(char**)0;
int rc,i;
long id;
int bytes;
int extra=sizeof(getmem_t)+GAnproc*sizeof(char*);
char *myptr;
Integer status;
type = pnga_type_f2c(type);
bytes = nelem * GAsizeofM(type);
if(GA_memory_limited){
GA_total_memory -= bytes+extra;
status = (GA_total_memory >= 0) ? 1 : 0;
/* pnga_gop(pnga_type_f2c(MT_F_INT), &status, 1, "*"); */
pnga_gop(pnga_type_f2c(MT_F_INT), &status, 1, "&&");
if(!status)GA_total_memory +=bytes+extra;
}else status = 1;
ptr_arr=malloc(GAnproc*sizeof(char**));
rc= gai_getmem("ga_getmem", ptr_arr,(Integer)bytes+extra, type, &id, grp_id);
if(rc)pnga_error("ga_getmem: failed to allocate memory",bytes+extra);
myptr = ptr_arr[GAme];
/* make sure that remote memory addresses point to user memory */
for(i=0; i<GAnproc; i++)ptr_arr[i] += extra;
#ifndef AVOID_MA_STORAGE
if(ARMCI_Uses_shm())
#endif
id += extra; /* id is used to store offset */
/* stuff the type and id info at the beginning */
((getmem_t*)myptr)->id = id;
((getmem_t*)myptr)->type = type;
((getmem_t*)myptr)->size = bytes+extra;
/* add ptr info */
memcpy(myptr+sizeof(getmem_t),ptr_arr,(size_t)GAnproc*sizeof(char**));
free(ptr_arr);
return (void*)(myptr+extra);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
movl %esi, %ebx
leaq 0x77856(%rip), %rax # 0xdc998
movl (%rax), %eax
leal 0x20(,%rax,8), %r13d
movslq %edi, %rdi
callq 0x99e0
movq %rax, %r15
movq %rax, %r12
shlq $0x20, %r12
movabsq $-0x3e800000000, %rax # imm = 0xFFFFFC1800000000
addq %r12, %rax
sarq $0x1c, %rax
leaq 0x7200a(%rip), %rcx # 0xd7180
imull 0x8(%rcx,%rax), %ebx
cmpb $0x1, 0x77776(%rip) # 0xdc8f8
jne 0x651db
leal (%rbx,%r13), %eax
movslq %eax, %rbp
movq 0x71fe6(%rip), %rax # 0xd7178
subq %rbp, %rax
movq %rax, 0x71fdc(%rip) # 0xd7178
notq %rax
shrq $0x3f, %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movl $0x3f2, %edi # imm = 0x3F2
callq 0x99e0
leaq 0x4c713(%rip), %rcx # 0xb18cf
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x781a5
cmpq $0x0, (%r14)
jne 0x651e4
addq %rbp, 0x71f9f(%rip) # 0xd7178
jmp 0x651e4
movq $0x1, 0x10(%rsp)
leaq 0x777ad(%rip), %rax # 0xdc998
movq (%rax), %rdi
shlq $0x3, %rdi
callq 0x33b0
movq %rax, %r14
movslq %ebx, %rsi
movslq %r13d, %rbp
addq %rbp, %rsi
leaq 0x8(%rsp), %rcx
movq %rax, %rdi
movl %r15d, %edx
movl 0x4(%rsp), %r8d
callq 0x64ec9
testl %eax, %eax
je 0x6522f
leal (%rbx,%r13), %eax
movslq %eax, %rsi
leaq 0x54c8f(%rip), %rdi # 0xb9eb9
callq 0x18f07
leaq 0x77772(%rip), %rax # 0xdc9a8
movq (%rax), %rax
movq (%r14,%rax,8), %r15
leaq 0x77754(%rip), %rax # 0xdc998
movq (%rax), %rax
testq %rax, %rax
jle 0x6525a
xorl %ecx, %ecx
addq %rbp, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x6524e
movq 0x8(%rsp), %rax
addq %rbp, %rax
movq %rax, 0x8(%rsp)
movq %rax, (%r15)
sarq $0x20, %r12
movq %r12, 0x8(%r15)
addl %r13d, %ebx
movslq %ebx, %rax
movq %rax, 0x10(%r15)
leaq 0x20(%r15), %rdi
leaq 0x77711(%rip), %rax # 0xdc998
movq (%rax), %rdx
shlq $0x3, %rdx
movq %r14, %rsi
callq 0x3220
movq %r14, %rdi
callq 0x3330
addq %rbp, %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_duplicate | logical pnga_duplicate(Integer g_a, Integer *g_b, char* array_name)
{
char **save_ptr;
C_Long mem_size, mem_size_proc;
Integer i, ga_handle, status;
int local_sync_begin,local_sync_end;
Integer grp_id, grp_me=GAme;
/* Integer grp_nproc=GAnproc; */
int maplen;
local_sync_begin = _ga_sync_begin; local_sync_end = _ga_sync_end;
_ga_sync_begin = 1; _ga_sync_end=1; /*remove any previous masking*/
grp_id = pnga_get_pgroup(g_a);
if(local_sync_begin)pnga_pgroup_sync(grp_id);
if (grp_id > 0) {
/* grp_nproc = PGRP_LIST[grp_id].map_nproc; */
grp_me = PGRP_LIST[grp_id].map_proc_list[GAme];
}
GAstat.numcre ++;
ga_check_handleM(g_a,"ga_duplicate");
/* find a free global_array handle for g_b */
ga_handle =-1; i=0;
do{
if(!GA[i].actv_handle) ga_handle=i;
i++;
}while(i<_max_global_array && ga_handle==-1);
if( ga_handle == -1)
pnga_error("ga_duplicate: too many arrays", (Integer)_max_global_array);
*g_b = (Integer)ga_handle - GA_OFFSET;
GA[ga_handle].actv_handle = 1;
gai_init_struct(ga_handle);
/*** copy content of the data structure ***/
save_ptr = GA[ga_handle].ptr;
GA[ga_handle] = GA[GA_OFFSET + g_a]; /* <--- shallow copy */
strcpy(GA[ga_handle].name, array_name);
GA[ga_handle].ptr = save_ptr;
GA[ga_handle].distr_type = GA[GA_OFFSET + g_a].distr_type;
maplen = calc_maplen(GA_OFFSET + g_a);
if (maplen > 0) {
GA[ga_handle].mapc = (C_Integer*)malloc((maplen+1)*sizeof(C_Integer*));
for(i=0;i<maplen; i++)GA[ga_handle].mapc[i] = GA[GA_OFFSET+ g_a].mapc[i];
GA[ga_handle].mapc[maplen] = -1;
}
/*** if ghost cells are used, initialize ghost cache data ***/
GA[ga_handle].cache = NULL;
pnga_set_ghost_info(*g_b);
/*** initialize and copy info for restricted arrays, if relevant ***/
GA[ga_handle].rstrctd_list = NULL;
GA[ga_handle].rank_rstrctd = NULL;
GA[ga_handle].num_rstrctd = 0;
if (GA[GA_OFFSET + g_a].num_rstrctd > 0) {
GA[ga_handle].num_rstrctd = GA[GA_OFFSET + g_a].num_rstrctd;
pnga_set_restricted(*g_b, GA[GA_OFFSET + g_a].rstrctd_list,
GA[GA_OFFSET + g_a].num_rstrctd);
}
/*** Memory Allocation & Initialization of GA Addressing Space ***/
mem_size = mem_size_proc = GA[ga_handle].size;
GA[ga_handle].id = INVALID_MA_HANDLE;
/* if requested, enforce limits on memory consumption */
if(GA_memory_limited) GA_total_memory -= mem_size_proc;
/* check if everybody has enough memory left */
if(GA_memory_limited){
status = (GA_total_memory >= 0) ? 1 : 0;
if (grp_id > 0) {
/* pnga_pgroup_gop(grp_id, pnga_type_f2c(MT_F_INT), &status, 1, "*"); */
pnga_pgroup_gop(grp_id, pnga_type_f2c(MT_F_INT), &status, 1, "&&");
status = (Integer)status;
} else {
/* pnga_gop(pnga_type_f2c(MT_F_INT), &status, 1, "*"); */
pnga_gop(pnga_type_f2c(MT_F_INT), &status, 1, "&&");
}
}else status = 1;
if(status)
{
if (GA[ga_handle].mem_dev_set) {
status = !gai_get_devmem(array_name, GA[ga_handle].ptr,mem_size,
(int)GA[ga_handle].type, &GA[ga_handle].id,
(int)grp_id,GA[ga_handle].mem_dev_set,GA[ga_handle].mem_dev);
} else {
status = !gai_getmem(array_name, GA[ga_handle].ptr,mem_size,
(int)GA[ga_handle].type, &GA[ga_handle].id,
(int)grp_id);
}
}
else{
GA[ga_handle].ptr[grp_me]=NULL;
}
if(local_sync_end)pnga_pgroup_sync(grp_id);
# ifdef GA_CREATE_INDEF
/* This code is incorrect. It needs to fixed if INDEF is ever used */
if(status){
Integer one = 1;
Integer dim1 =(Integer)GA[ga_handle].dims[1], dim2=(Integer)GA[ga_handle].dims[2];
if(GAme==0)fprintf(stderr,"duplicate:initializing GA array%ld\n",g_b);
if(GA[ga_handle].type == C_DBL) {
double bad = (double) DBL_MAX;
ga_fill_patch_(g_b, &one, &dim1, &one, &dim2, &bad);
} else if (GA[ga_handle].type == C_INT) {
int bad = (int) INT_MAX;
ga_fill_patch_(g_b, &one, &dim1, &one, &dim2, &bad);
} else if (GA[ga_handle].type == C_LONG) {
long bad = LONG_MAX;
ga_fill_patch_(g_b, &one, &dim1, &one, &dim2, &bad);
} else if (GA[ga_handle].type == C_LONGLONG) {
long long bad = LONG_MAX;
ga_fill_patch_(g_b, &one, &dim1, &one, &dim2, &bad);
} else if (GA[ga_handle].type == C_DCPL) {
DoubleComplex bad = {DBL_MAX, DBL_MAX};
ga_fill_patch_(g_b, &one, &dim1, &one, &dim2, &bad);
} else if (GA[ga_handle].type == C_SCPL) {
SingleComplex bad = {FLT_MAX, FLT_MAX};
ga_fill_patch_(g_b, &one, &dim1, &one, &dim2, &bad);
} else if (GA[ga_handle].type == C_FLOAT) {
float bad = FLT_MAX;
ga_fill_patch_(g_b, &one, &dim1, &one, &dim2, &bad);
} else {
pnga_error("ga_duplicate: type not supported ",GA[ga_handle].type);
}
}
# endif
if(status){
GAstat.curmem += (long)GA[ga_handle].size;
GAstat.maxmem = (long)GA_MAX(GAstat.maxmem, GAstat.curmem);
return(TRUE);
}else{
if (GA_memory_limited) GA_total_memory += mem_size_proc;
pnga_destroy(*g_b);
return(FALSE);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdx, 0x28(%rsp)
movq %rsi, %r15
movq %rdi, %r13
leaq 0x775be(%rip), %r14 # 0xdc9a8
movq (%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0x71d67(%rip), %rax # 0xd7160
leaq 0x71d64(%rip), %rcx # 0xd7164
movl (%rcx), %edx
movl %edx, 0x14(%rsp)
imulq $0x368, %rdi, %rdx # imm = 0x368
cmpl $0x0, (%rax)
movl $0x1, %esi
movl %esi, (%rax)
movl %esi, (%rcx)
leaq 0x77498(%rip), %rbx # 0xdc8b8
movq (%rbx), %rax
movslq 0xd5050(%rax,%rdx), %r12
je 0x65435
movq %r12, %rdi
callq 0x6979c
movq %r15, 0x20(%rsp)
testl %r12d, %r12d
jle 0x6545e
leaq 0x774ca(%rip), %rax # 0xdc910
movq (%rax), %rax
leaq (%r12,%r12,4), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq (%r14), %rcx
movslq (%rax,%rcx,4), %rax
movq %rax, 0x18(%rsp)
movq %r12, 0x8(%rsp)
leaq 0x774ae(%rip), %rax # 0xdc918
incq (%rax)
leaq 0x3e8(%r13), %r12
leaq 0x71ced(%rip), %r14 # 0xd7168
cmpq $-0x3e8, %r13 # imm = 0xFC18
jl 0x6548c
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x654b4
leaq 0x53e45(%rip), %rsi # 0xb92d8
leaq 0x54a5d(%rip), %rdx # 0xb9ef7
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
xorl %eax, %eax
callq 0x30a0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x18f07
movq (%rbx), %rax
imulq $0x368, %r12, %r15 # imm = 0x368
cmpl $0x0, 0x8(%rax,%r15)
jne 0x654ee
leaq 0x53e24(%rip), %rsi # 0xb92f1
leaq 0x54a23(%rip), %rdx # 0xb9ef7
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
xorl %eax, %eax
callq 0x30a0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x18f07
movq (%rbx), %rax
movslq (%r14), %rsi
addq $0xc, %rax
movq $-0x1, %rdi
movl (%rax), %ecx
leaq 0x1(%rdi), %rdx
testl %ecx, %ecx
je 0x6551b
addq $0x2, %rdi
addq $0x368, %rax # imm = 0x368
cmpq %rsi, %rdi
movq %rdx, %rdi
jl 0x654ff
xorl %r13d, %r13d
movl %ecx, %eax
negl %eax
sbbq %r13, %r13
orq %rdx, %r13
testl %ecx, %ecx
je 0x65538
leaq 0x549d1(%rip), %rdi # 0xb9f04
callq 0x18f07
leaq -0x3e8(%r13), %rax
movq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
imulq $0x368, %r13, %rbp # imm = 0x368
movl $0x1, 0xc(%rax,%rbp)
movl %r13d, %edi
callq 0x5fa49
movq (%rbx), %rsi
leaq (%rsi,%rbp), %rdi
leaq (%rsi,%rbp), %r13
addq $0x1f0, %r13 # imm = 0x1F0
movq -0x10(%r13), %r14
addq %r15, %rsi
movl $0x368, %edx # imm = 0x368
callq 0x3220
movq %r13, %rdi
movq 0x28(%rsp), %rsi
callq 0x3250
movq (%rbx), %rax
movq %r14, 0x1e0(%rax,%rbp)
movq (%rbx), %r13
movl 0x224(%r13,%r15), %eax
movl %eax, 0x224(%r13,%rbp)
movl %r12d, %edi
callq 0x657f7
testl %eax, %eax
jle 0x6560b
movl %eax, %r14d
leaq 0x8(,%r14,8), %rdi
callq 0x33b0
movq %rax, 0x1e8(%r13,%rbp)
movq (%rbx), %rcx
movq 0x1e8(%rcx,%r15), %rax
movq 0x1e8(%rcx,%rbp), %rcx
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0x655e8
movq (%rbx), %rax
movq 0x1e8(%rax,%rbp), %rax
movq $-0x1, (%rax,%r14,8)
movq (%rbx), %rax
xorl %r14d, %r14d
movq %r14, 0x218(%rax,%rbp)
movq 0x20(%rsp), %r12
movq (%r12), %rdi
callq 0x8d616
movq (%rbx), %rax
movq %r14, 0x2a0(%rax,%rbp)
movq (%rbx), %rax
movq %r14, 0x2c0(%rax,%rbp)
movq (%rbx), %rax
movq %r14, 0x2a8(%rax,%rbp)
movq 0x2a8(%rax,%r15), %rcx
testq %rcx, %rcx
jle 0x6567c
leaq (%rax,%rbp), %rdx
addq $0x2a8, %rdx # imm = 0x2A8
movq %rcx, (%rdx)
movq (%r12), %rdi
movq 0x2a0(%rax,%r15), %rsi
movq 0x2a8(%rax,%r15), %rdx
callq 0x61205
movq (%rbx), %rax
movq 0x10(%rax,%rbp), %r15
movq $-0x1, 0x28(%rax,%rbp)
cmpb $0x1, 0x77264(%rip) # 0xdc8f8
jne 0x656e1
movq 0x71adb(%rip), %rax # 0xd7178
subq %r15, %rax
movq %rax, 0x71ad1(%rip) # 0xd7178
notq %rax
shrq $0x3f, %rax
movq %rax, 0x30(%rsp)
movl $0x3f2, %edi # imm = 0x3F2
callq 0x99e0
movq 0x8(%rsp), %rdi
testl %edi, %edi
jle 0x656ec
leaq 0x4c202(%rip), %r8 # 0xb18cf
leaq 0x30(%rsp), %rdx
movl $0x1, %ecx
movq %rax, %rsi
callq 0x7807b
jmp 0x65705
movq $0x1, 0x30(%rsp)
jmp 0x65705
leaq 0x4c1dc(%rip), %rcx # 0xb18cf
leaq 0x30(%rsp), %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x781a5
cmpq $0x0, 0x30(%rsp)
movq (%rbx), %rax
je 0x6574c
leaq (%rax,%rbp), %r8
addq $0x28, %r8
movl 0x318(%r8), %edi
movq 0x1b8(%r8), %rsi
movl -0x24(%r8), %ecx
testl %edi, %edi
je 0x65763
addq %rbp, %rax
addq $0x344, %rax # imm = 0x344
movq %r15, %rdx
movq 0x8(%rsp), %r9
pushq %rax
pushq %rdi
callq 0x63016
addq $0x10, %rsp
jmp 0x65778
movq 0x1e0(%rax,%rbp), %rax
movq 0x18(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x65784
movq %rsi, %rdi
movq %r15, %rsi
movl %ecx, %edx
movq %r8, %rcx
movq 0x8(%rsp), %r8
callq 0x64ec9
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movq %rcx, 0x30(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x65795
movq 0x8(%rsp), %rdi
callq 0x6979c
cmpq $0x0, 0x30(%rsp)
je 0x657ca
movq (%rbx), %rax
leaq 0x77171(%rip), %rsi # 0xdc918
movq 0x48(%rsi), %rcx
movq 0x50(%rsi), %rdx
addq 0x10(%rax,%rbp), %rcx
movq %rcx, 0x48(%rsi)
cmpq %rcx, %rdx
cmovgq %rdx, %rcx
movq %rcx, 0x50(%rsi)
movl $0x1, %eax
jmp 0x657e5
cmpb $0x1, 0x77127(%rip) # 0xdc8f8
jne 0x657da
addq %r15, 0x7199e(%rip) # 0xd7178
movq (%r12), %rdi
callq 0x63281
xorl %eax, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_locate_region | logical pnga_locate_region( Integer g_a,
Integer *lo,
Integer *hi,
Integer *map,
Integer *proclist,
Integer *np)
/* g_a [input] global array handle
lo [input] lower indices of patch in global array
hi [input] upper indices of patch in global array
map [output] list of lower and upper indices for portion of
patch that exists on each processor containing a
portion of the patch. The map is constructed so
that for a D dimensional global array, the first
D elements are the lower indices on the first
processor in proclist, the next D elements are
the upper indices of the first processor in
proclist, the next D elements are the lower
indices for the second processor in proclist, and
so on.
proclist [output] list of processors containing some portion of the
patch
np [output] total number of processors containing a portion
of the patch
For a block cyclic data distribution, this function returns a list of
blocks that cover the region along with the lower and upper indices of
each block.
*/
{
int procT[MAXDIM], procB[MAXDIM], proc_subscript[MAXDIM];
Integer proc, owner, i, ga_handle;
Integer d, dpos, ndim, elems, use_blocks;
/* Integer p_handle; */
ga_check_handleM(g_a, "nga_locate_region");
ga_handle = GA_OFFSET + g_a;
for(d = 0; d< GA[ga_handle].ndim; d++)
if((lo[d]<1 || hi[d]>GA[ga_handle].dims[d]) ||(lo[d]>hi[d]))return FALSE;
ndim = GA[ga_handle].ndim;
if (GA[ga_handle].distr_type == REGULAR) {
/* find "processor coordinates" for the top left corner and store them
* in ProcT */
for(d = 0, dpos = 0; d< GA[ga_handle].ndim; d++){
findblock(GA[ga_handle].mapc + dpos, GA[ga_handle].nblock[d],
GA[ga_handle].scale[d], lo[d], &procT[d]);
dpos += GA[ga_handle].nblock[d];
}
/* find "processor coordinates" for the right bottom corner and store
* them in procB */
for(d = 0, dpos = 0; d< GA[ga_handle].ndim; d++){
findblock(GA[ga_handle].mapc + dpos, GA[ga_handle].nblock[d],
GA[ga_handle].scale[d], hi[d], &procB[d]);
dpos += GA[ga_handle].nblock[d];
}
*np = 0;
/* Find total number of processors containing data and return the
* result in elems. Also find the lowest "processor coordinates" of the
* processor block containing data and return these in proc_subscript.
*/
ga_InitLoopM(&elems, ndim, proc_subscript, procT,procB,GA[ga_handle].nblock);
/* p_handle = (Integer)GA[ga_handle].p_handle; */
for(i= 0; i< elems; i++){
Integer _lo[MAXDIM], _hi[MAXDIM];
Integer offset;
/* convert i to owner processor id using the current values in
proc_subscript */
ga_ComputeIndexM(&proc, ndim, proc_subscript, GA[ga_handle].nblock);
/* get range of global array indices that are owned by owner */
ga_ownsM(ga_handle, proc, _lo, _hi);
offset = *np *(ndim*2); /* location in map to put patch range */
for(d = 0; d< ndim; d++)
map[d + offset ] = lo[d] < _lo[d] ? _lo[d] : lo[d];
for(d = 0; d< ndim; d++)
map[ndim + d + offset ] = hi[d] > _hi[d] ? _hi[d] : hi[d];
owner = proc;
if (GA[ga_handle].num_rstrctd == 0) {
proclist[i] = owner;
} else {
proclist[i] = GA[ga_handle].rstrctd_list[owner];
}
/* Update to proc_subscript so that it corresponds to the next
* processor in the block of processors containing the patch */
ga_UpdateSubscriptM(ndim,proc_subscript,procT,procB,GA[ga_handle].nblock);
(*np)++;
}
} else if (GA[ga_handle].distr_type == TILED_IRREG) {
Integer nproc = pnga_pgroup_nnodes(GA[ga_handle].p_handle);
/* find "processor coordinates" for the top left corner and store them
* in ProcT */
for(d = 0, dpos = 0; d< GA[ga_handle].ndim; d++){
findblock(GA[ga_handle].mapc + dpos, GA[ga_handle].num_blocks[d],
GA[ga_handle].scale[d], lo[d], &procT[d]);
dpos += GA[ga_handle].num_blocks[d];
}
/* find "processor coordinates" for the right bottom corner and store
* them in procB */
for(d = 0, dpos = 0; d< GA[ga_handle].ndim; d++){
findblock(GA[ga_handle].mapc + dpos, GA[ga_handle].num_blocks[d],
GA[ga_handle].scale[d], hi[d], &procB[d]);
dpos += GA[ga_handle].num_blocks[d];
}
*np = 0;
/* Find total number of processors containing data and return the
* result in elems. Also find the lowest "processor coordinates" of the
* processor block containing data and return these in proc_subscript.
*/
ga_InitLoopM(&elems, ndim, proc_subscript, procT,procB,GA[ga_handle].num_blocks);
/* p_handle = (Integer)GA[ga_handle].p_handle; */
for(i= 0; i< elems; i++){
Integer _lo[MAXDIM], _hi[MAXDIM];
Integer offset;
/* convert i to owner processor id using the current values in
proc_subscript */
ga_ComputeIndexM(&proc, ndim, proc_subscript, GA[ga_handle].num_blocks);
proclist[i] = proc;
/* get range of global array indices that are owned by owner */
ga_ownsM(ga_handle, proc, _lo, _hi);
offset = *np *(ndim*2); /* location in map to put patch range */
for(d = 0; d< ndim; d++)
map[d + offset ] = lo[d] < _lo[d] ? _lo[d] : lo[d];
for(d = 0; d< ndim; d++)
map[ndim + d + offset ] = hi[d] > _hi[d] ? _hi[d] : hi[d];
/* Update to proc_subscript so that it corresponds to the next
* processor in the block of processors containing the patch */
ga_UpdateSubscriptM(ndim,proc_subscript,procT,procB,GA[ga_handle].num_blocks);
(*np)++;
}
} else if (GA[ga_handle].distr_type == BLOCK_CYCLIC) {
Integer nblocks = GA[ga_handle].block_total;
Integer chk, j, tlo[MAXDIM], thi[MAXDIM], cnt;
Integer offset;
cnt = 0;
for (i=0; i<nblocks; i++) {
/* check to see if this block overlaps with requested block
* defined by lo and hi */
chk = 1;
/* get limits on block i */
pnga_distribution(g_a,i,tlo,thi);
for (j=0; j<ndim && chk==1; j++) {
/* check to see if at least one end point of the interval
* represented by blo and bhi falls in the interval
* represented by lo and hi */
if (!((tlo[j] >= lo[j] && tlo[j] <= hi[j]) ||
(thi[j] >= lo[j] && thi[j] <= hi[j]))) {
chk = 0;
}
}
/* store blocks that overlap request region in proclist */
if (chk) {
proclist[cnt] = i;
cnt++;
}
}
*np = cnt;
/* fill map array with block coordinates */
for (i=0; i<cnt; i++) {
offset = i*2*ndim;
j = proclist[i];
pnga_distribution(g_a,j,tlo,thi);
for (j=0; j<ndim; j++) {
map[offset + j] = lo[j] < tlo[j] ? tlo[j] : lo[j];
map[offset + ndim + j] = hi[j] > thi[j] ? thi[j] : hi[j];
}
}
} else if (GA[ga_handle].distr_type == SCALAPACK ||
GA[ga_handle].distr_type == TILED) {
/* find min and max block coordinates of region */
Integer min[MAXDIM], max[MAXDIM];
Integer count[MAXDIM];
Integer total_blocks = 1;
Integer cnt = 0;
Integer offset;
for (i=0; i<ndim; i++) {
min[i] = (lo[i]-1)/GA[ga_handle].block_dims[i];
max[i] = (hi[i]-1)/GA[ga_handle].block_dims[i];
total_blocks *= (max[i]-min[i]+1);
count[i] = min[i];
}
while (count[ndim-1]<=max[ndim-1]) {
/* Calculate block index */
Integer idx = 0;
Integer factor = 1;
Integer iproc;
Integer p_handle = GA[ga_handle].p_handle;
Integer size = pnga_pgroup_nnodes(p_handle);
for (i=ndim-1; i>=0; i--) {
idx = idx*factor+count[i];
factor *= GA[ga_handle].num_blocks[i];
}
proclist[cnt] = idx;
/* store information on this block */
offset = 2*cnt*ndim;
for (i=0; i<ndim; i++) {
map[offset+i] = count[i]*GA[ga_handle].block_dims[i]+1;
map[offset+ndim+i] = (count[i]+1)*GA[ga_handle].block_dims[i];
if (map[offset+ndim+i] > GA[ga_handle].dims[i])
map[offset+ndim+i] = GA[ga_handle].dims[i];
}
cnt++;
/* Increment count array */
i = 0;
count[0]++;
while (count[i] > max[i] && i<ndim) {
if (i<ndim-1) count[i] = min[i];
if (i<ndim-1) {
count[i+1]++;
}
i++;
}
}
*np = cnt;
}
return(TRUE);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %r9, 0x28(%rsp)
movq %r8, 0x50(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r13
leaq 0x3e8(%rdi), %r15
movq %rdi, 0x10(%rsp)
cmpq $-0x3e8, %rdi # imm = 0xFC18
jl 0x67140
leaq 0x70030(%rip), %rax # 0xd7168
movslq (%rax), %rax
cmpq %rax, %r15
jl 0x6716d
leaq 0x52191(%rip), %rsi # 0xb92d8
leaq 0x52e78(%rip), %rdx # 0xb9fc6
leaq 0x160(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30a0
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x18f07
leaq 0x75744(%rip), %r14 # 0xdc8b8
movq (%r14), %rax
imulq $0x368, %r15, %r15 # imm = 0x368
cmpl $0x0, 0x8(%rax,%r15)
jne 0x671b3
leaq 0x52164(%rip), %rsi # 0xb92f1
leaq 0x52e32(%rip), %rdx # 0xb9fc6
leaq 0x160(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30a0
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x18f07
movq (%r14), %r11
leaq (%r11,%r15), %r10
movswq (%r11,%r15), %rbp
testq %rbp, %rbp
jle 0x671f6
xorl %ebx, %ebx
xorl %eax, %eax
movq (%r13,%rax,8), %rcx
testq %rcx, %rcx
jle 0x68405
movq (%r12,%rax,8), %rdx
cmpq %rdx, %rcx
jg 0x68405
cmpq 0x30(%r10,%rax,8), %rdx
jg 0x68405
incq %rax
cmpq %rax, %rbp
jne 0x671c8
movl 0x224(%r10), %edx
movl $0x1, %ebx
cmpq $0x4, %rdx
ja 0x68405
movq %r15, 0x38(%rsp)
leaq 0x51f68(%rip), %rax # 0xb9180
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
movq %r11, %r15
movq %r10, 0x8(%rsp)
movq %rdx, 0xd8(%rsp)
jmpq *%rcx
testw %bp, %bp
jle 0x6728c
imulq $0x368, 0x10(%rsp), %rax # imm = 0x368
leaq (%rax,%r11), %rsi
addq $0xd5068, %rsi # imm = 0xD5068
xorl %edi, %edi
movq (%r13,%rdi,8), %rax
decq %rax
movq (%rsi,%rdi,8), %r8
cqto
idivq %r8
movq %rax, %rcx
movq %rax, 0x160(%rsp,%rdi,8)
movq (%r12,%rdi,8), %rax
decq %rax
cqto
idivq %r8
movq %rax, 0xa0(%rsp,%rdi,8)
movq %rcx, 0x100(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %rbp
jne 0x6724c
movq 0x98(%rsp,%rbp,8), %rax
cmpq %rax, 0xf8(%rsp,%rbp,8)
jle 0x6820f
xorl %edx, %edx
jmp 0x6834a
testw %bp, %bp
jle 0x67391
movq 0x1e8(%r10), %rax
leaq 0x8(%rax), %rcx
xorl %edx, %edx
xorl %esi, %esi
movq (%r13,%rdx,8), %r8
xorps %xmm0, %xmm0
cvtsi2sd %r8, %xmm0
mulsd 0x1a8(%r10,%rdx,8), %xmm0
cvttsd2si %xmm0, %edi
movslq %edi, %rdi
movq 0x260(%r10,%rdx,8), %r9
movq %r10, %rbx
leal -0x1(%r9), %r10d
cmpq %rdi, %r9
cmovel %r10d, %edi
leaq (%rax,%rsi,8), %r11
movslq %edi, %r10
cmpq %r8, (%r11,%r10,8)
jle 0x67323
testl %edi, %edi
jle 0x6735d
movl %edi, %r10d
leal -0x1(%r10), %edi
cmpq %r8, (%r11,%rdi,8)
setle %r9b
jle 0x67362
decl %r10d
jg 0x67309
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
jmp 0x67362
movq 0x260(%rbx,%rdx,8), %r11
decq %r11
cmpq %r10, %r11
jle 0x6735f
incl %edi
movslq %edi, %rdi
cmpq %rdi, %r11
cmovgq %r11, %rdi
leaq (%rcx,%rsi,8), %rbx
cmpq %r8, (%rbx,%r10,8)
setg %r9b
jg 0x67358
incq %r10
cmpq %r10, %r11
jg 0x67343
movq %rdi, %r10
movl %r10d, %edi
jmp 0x67362
decl %edi
xorl %r9d, %r9d
testb %r9b, %r9b
movq 0x8(%rsp), %r10
jne 0x67376
movl 0x260(%r10,%rdx,8), %edi
decl %edi
movl %edi, 0x100(%rsp,%rdx,4)
addq 0x260(%r10,%rdx,8), %rsi
incq %rdx
cmpq %rbp, %rdx
jne 0x672c1
testw %bp, %bp
jle 0x67478
movq 0x1e8(%r10), %rax
leaq 0x8(%rax), %rcx
xorl %edx, %edx
xorl %esi, %esi
movq (%r12,%rdx,8), %r8
xorps %xmm0, %xmm0
cvtsi2sd %r8, %xmm0
mulsd 0x1a8(%r10,%rdx,8), %xmm0
cvttsd2si %xmm0, %edi
movslq %edi, %rdi
movq 0x260(%r10,%rdx,8), %r9
movq %r10, %rbx
leal -0x1(%r9), %r10d
cmpq %rdi, %r9
cmovel %r10d, %edi
leaq (%rax,%rsi,8), %r11
movslq %edi, %r10
cmpq %r8, (%r11,%r10,8)
jle 0x6740a
testl %edi, %edi
jle 0x67444
movl %edi, %r10d
leal -0x1(%r10), %edi
cmpq %r8, (%r11,%rdi,8)
setle %r9b
jle 0x67449
decl %r10d
jg 0x673f0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
jmp 0x67449
movq 0x260(%rbx,%rdx,8), %r11
decq %r11
cmpq %r10, %r11
jle 0x67446
incl %edi
movslq %edi, %rdi
cmpq %rdi, %r11
cmovgq %r11, %rdi
leaq (%rcx,%rsi,8), %rbx
cmpq %r8, (%rbx,%r10,8)
setg %r9b
jg 0x6743f
incq %r10
cmpq %r10, %r11
jg 0x6742a
movq %rdi, %r10
movl %r10d, %edi
jmp 0x67449
decl %edi
xorl %r9d, %r9d
testb %r9b, %r9b
movq 0x8(%rsp), %r10
jne 0x6745d
movl 0x260(%r10,%rdx,8), %edi
decl %edi
movl %edi, 0x140(%rsp,%rdx,4)
addq 0x260(%r10,%rdx,8), %rsi
incq %rdx
cmpq %rbp, %rdx
jne 0x673a9
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
movl $0x1, %ebx
movl $0x1, %edx
testw %bp, %bp
jle 0x674db
leaq (,%rbp,4), %rdx
leaq 0xe0(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x3220
movq 0x8(%rsp), %r10
movl $0x1, %edx
xorl %eax, %eax
movl 0x140(%rsp,%rax,4), %ecx
subl 0x100(%rsp,%rax,4), %ecx
incl %ecx
movslq %ecx, %rcx
imulq %rcx, %rdx
incq %rax
cmpq %rax, %rbp
jne 0x674bc
testq %rdx, %rdx
jle 0x68405
leaq -0x1(%rbp), %r14
movq %r15, %r11
movq 0x38(%rsp), %rax
addq %r15, %rax
addq $0x1e8, %rax # imm = 0x1E8
movq %rax, 0x80(%rsp)
leaq (%rbp,%rbp), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
leaq (%rax,%rbp,8), %rax
movq %rax, 0x58(%rsp)
movl %ebp, %r9d
leaq (,%r9,8), %rax
movq %rax, 0x40(%rsp)
leaq (,%rbp,8), %rax
movq %rax, 0x20(%rsp)
imulq $0x368, 0x10(%rsp), %rax # imm = 0x368
addq %rax, %r15
addq $0xd50a0, %r15 # imm = 0xD50A0
leaq (%r11,%rax), %rbx
addq $0xd50a8, %rbx # imm = 0xD50A8
leaq -0x1(%r9), %r8
shlq $0x2, %r9
addq %rax, %r11
movq $0x0, 0x10(%rsp)
movq %r11, 0x30(%rsp)
movq %r9, 0x90(%rsp)
movq %r8, 0x88(%rsp)
movq %rdx, 0x98(%rsp)
testw %bp, %bp
jle 0x675bf
movl $0x1, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movq %rdx, %rsi
cmpq %r14, %rax
jge 0x675a3
movq (%r15,%rax,8), %rsi
imulq %rdx, %rsi
movslq 0xe0(%rsp,%rax,4), %rdi
imulq %rdi, %rdx
addq %rdx, %rcx
incq %rax
movq %rsi, %rdx
cmpq %rax, %rbp
jne 0x67596
jmp 0x675c1
xorl %ecx, %ecx
movq 0x50(%rsp), %rax
movq 0x10(%rsp), %rdx
movq %rcx, (%rax,%rdx,8)
movq 0xd8(%rsp), %rdx
leal -0x1(%rdx), %eax
cmpl $0x3, %eax
jae 0x6767e
movslq %ecx, %rax
cqto
idivq 0x260(%r10)
movl %edx, 0x60(%rsp)
cmpw $0x2, %bp
jl 0x67623
movl 0x60(%rsp), %edx
xorl %esi, %esi
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rbx,%rsi,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rbx,%rsi,8)
movl %edx, 0x64(%rsp,%rsi,4)
incq %rsi
cmpq %rsi, %r8
jne 0x675ff
testw %bp, %bp
jle 0x6791f
xorl %eax, %eax
movslq 0x60(%rsp,%rax), %rcx
movq -0x38(%r15,%rax,2), %rdx
movq %rdx, %rsi
imulq %rcx, %rsi
incq %rsi
movq %rsi, 0x160(%rsp,%rax,2)
incq %rcx
imulq %rdx, %rcx
movq %rcx, 0xa0(%rsp,%rax,2)
movq -0x230(%r15,%rax,2), %rdx
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
movq %rcx, 0xa0(%rsp,%rax,2)
addq $0x4, %rax
cmpq %rax, %r9
jne 0x6762e
jmp 0x6791f
cmpl $0x4, %edx
je 0x6775a
testl %edx, %edx
jne 0x6791f
movq 0x2a8(%r10), %rax
testq %rax, %rax
je 0x6780d
cmpq %rax, %rcx
jge 0x678e5
movl $0x1, %eax
testw %bp, %bp
jle 0x676c8
xorl %edx, %edx
movslq -0x1c0(%r15,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %rbp
jne 0x676b4
testq %rcx, %rcx
js 0x678b8
cmpq %rax, %rcx
jge 0x678b8
testw %bp, %bp
jle 0x6791f
movq 0x1e8(%r10), %rax
movq %rax, 0x48(%rsp)
xorl %edi, %edi
xorl %r8d, %r8d
movslq 0xd4ee0(%r11,%r8,4), %r9
movq %rcx, %rax
cqto
idivq %r9
movq 0x48(%rsp), %rcx
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %rcx
movq %rcx, 0x160(%rsp,%r8,8)
movq %r11, %rsi
leaq -0x1(%r9), %r11
movq %rax, %rcx
cmpq %r11, %rdx
jne 0x67732
movq 0xd4e70(%rsi,%r8,8), %rax
jmp 0x6773a
movq 0x8(%r10,%rdi,8), %rax
decq %rax
movq %rsi, %r11
addq %r9, %rdi
movq %rax, 0xa0(%rsp,%r8,8)
incq %r8
cmpq %r8, %rbp
movq 0x8(%rsp), %r10
jne 0x676f4
jmp 0x6791f
movslq %ecx, %rax
cqto
idivq 0x260(%r10)
movl %edx, 0x60(%rsp)
cmpw $0x2, %bp
jl 0x6779a
movl 0x60(%rsp), %edx
xorl %esi, %esi
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rbx,%rsi,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rbx,%rsi,8)
movl %edx, 0x64(%rsp,%rsi,4)
incq %rsi
cmpq %rsi, %r8
jne 0x67776
testw %bp, %bp
jle 0x6791f
movq 0x80(%rsp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x60(%rsp,%rcx), %rdi
movslq %edx, %rsi
addq %rdi, %rsi
movq (%rax,%rsi,8), %r8
movq %r8, 0x160(%rsp,%rcx,2)
movq 0x260(%r10,%rcx,2), %r8
decq %r8
cmpq %rdi, %r8
jle 0x677ea
movq 0x1e8(%r10), %rdi
movq 0x8(%rdi,%rsi,8), %rsi
decq %rsi
jmp 0x677ef
movq 0x30(%r10,%rcx,2), %rsi
movq %rsi, 0xa0(%rsp,%rcx,2)
addl 0x260(%r10,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %r9
jne 0x677b2
jmp 0x6791f
movl $0x1, %eax
testw %bp, %bp
jle 0x6782d
xorl %edx, %edx
movslq -0x1c0(%r15,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %rbp
jne 0x67819
testq %rcx, %rcx
js 0x678b8
cmpq %rax, %rcx
jge 0x678b8
testw %bp, %bp
jle 0x6791f
movq 0x1e8(%r10), %rax
movq %rax, 0x48(%rsp)
xorl %edi, %edi
xorl %r8d, %r8d
movslq 0xd4ee0(%r11,%r8,4), %r9
movq %rcx, %rax
cqto
idivq %r9
movq 0x48(%rsp), %rcx
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %rcx
movq %rcx, 0x160(%rsp,%r8,8)
movq %r11, %rsi
leaq -0x1(%r9), %r11
movq %rax, %rcx
cmpq %r11, %rdx
jne 0x67893
movq 0xd4e70(%rsi,%r8,8), %rax
jmp 0x6789b
movq 0x8(%r10,%rdi,8), %rax
decq %rax
movq %rsi, %r11
addq %r9, %rdi
movq %rax, 0xa0(%rsp,%r8,8)
incq %r8
cmpq %r8, %rbp
movq 0x8(%rsp), %r10
jne 0x67855
jmp 0x6791f
testw %bp, %bp
jle 0x6791f
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
movq 0x20(%rsp), %rdx
callq 0x3170
leaq 0xa0(%rsp), %rdi
movl $0xff, %esi
movq 0x20(%rsp), %rdx
jmp 0x67910
testw %bp, %bp
jle 0x6791f
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
movq 0x40(%rsp), %rdx
callq 0x3170
leaq 0xa0(%rsp), %rdi
movl $0xff, %esi
movq 0x40(%rsp), %rdx
callq 0x3170
movq 0x8(%rsp), %r10
movq 0x30(%rsp), %r11
movq 0x28(%rsp), %rax
movq (%rax), %rax
imulq 0x38(%rsp), %rax
testw %bp, %bp
movq 0x18(%rsp), %rcx
jle 0x6795d
leaq (%rcx,%rax,8), %rcx
xorl %edx, %edx
movq (%r13,%rdx,8), %rsi
movq 0x160(%rsp,%rdx,8), %rdi
cmpq %rdi, %rsi
cmovgq %rsi, %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x6793d
testw %bp, %bp
movq 0x88(%rsp), %r8
jle 0x67994
movq 0x58(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
xorl %ecx, %ecx
movq (%r12,%rcx,8), %rdx
movq 0xa0(%rsp,%rcx,8), %rsi
cmpq %rsi, %rdx
cmovlq %rdx, %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x67975
testw %bp, %bp
movq 0x98(%rsp), %rdx
movq 0x90(%rsp), %r9
jle 0x679dc
xorl %eax, %eax
movl 0xe0(%rsp,%rax,4), %ecx
cmpl 0x140(%rsp,%rax,4), %ecx
jl 0x679d3
movl 0x100(%rsp,%rax,4), %ecx
movl %ecx, 0xe0(%rsp,%rax,4)
incq %rax
cmpq %rax, %rbp
jne 0x679ab
jmp 0x679dc
incl %ecx
movl %ecx, 0xe0(%rsp,%rax,4)
movq 0x28(%rsp), %rax
incq (%rax)
movq 0x10(%rsp), %rcx
incq %rcx
movq %rcx, 0x10(%rsp)
cmpq %rdx, %rcx
jne 0x67585
jmp 0x68400
testw %bp, %bp
jle 0x67af5
movq 0x1e8(%r10), %rax
leaq 0x8(%rax), %rcx
xorl %edx, %edx
xorl %esi, %esi
movq (%r13,%rdx,8), %r8
xorps %xmm0, %xmm0
cvtsi2sd %r8, %xmm0
mulsd 0x1a8(%r10,%rdx,8), %xmm0
cvttsd2si %xmm0, %r9d
movq %r10, %rbx
movl 0xa0(%r10,%rdx,4), %r10d
leal -0x1(%r10), %edi
cmpl %r9d, %r10d
cmovnel %r9d, %edi
leaq (%rax,%rsi,8), %r10
movslq %edi, %r9
cmpq %r8, (%r10,%r9,8)
jle 0x67a77
testl %edi, %edi
jle 0x67ab6
movl %edi, %r11d
leal -0x1(%r11), %edi
cmpq %r8, (%r10,%rdi,8)
setle %r9b
jle 0x67ac0
decl %r11d
jg 0x67a5d
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
jmp 0x67ac0
movslq 0xa0(%rbx,%rdx,4), %rbx
leal -0x1(%rbx), %r10d
cmpl %r10d, %edi
jge 0x67ab8
movq %r9, %r11
notq %r11
addq %rbx, %r11
shlq $0x3, %r9
leaq (%r9,%rsi,8), %rbx
addq %rcx, %rbx
xorl %r14d, %r14d
cmpq %r8, (%rbx,%r14,8)
setg %r9b
jg 0x67abd
incq %r14
cmpq %r14, %r11
jne 0x67a9f
movl %r10d, %edi
jmp 0x67ac0
decl %edi
xorl %r9d, %r9d
jmp 0x67ac3
addl %r14d, %edi
movq %r15, %r11
testb %r9b, %r9b
movq 0x8(%rsp), %r10
jne 0x67ad7
movl 0xa0(%r10,%rdx,4), %edi
decl %edi
movl %edi, 0x100(%rsp,%rdx,4)
movslq 0xa0(%r10,%rdx,4), %rdi
addq %rdi, %rsi
incq %rdx
cmpq %rbp, %rdx
jne 0x67a17
testw %bp, %bp
jle 0x67bea
movq 0x1e8(%r10), %rax
leaq 0x8(%rax), %rcx
xorl %edx, %edx
xorl %esi, %esi
movq (%r12,%rdx,8), %r8
xorps %xmm0, %xmm0
cvtsi2sd %r8, %xmm0
mulsd 0x1a8(%r10,%rdx,8), %xmm0
cvttsd2si %xmm0, %r9d
movq %r10, %rbx
movl 0xa0(%r10,%rdx,4), %r10d
leal -0x1(%r10), %edi
cmpl %r9d, %r10d
cmovnel %r9d, %edi
leaq (%rax,%rsi,8), %r10
movslq %edi, %r9
cmpq %r8, (%r10,%r9,8)
jle 0x67b6c
testl %edi, %edi
jle 0x67bab
movl %edi, %r11d
leal -0x1(%r11), %edi
cmpq %r8, (%r10,%rdi,8)
setle %r9b
jle 0x67bb5
decl %r11d
jg 0x67b52
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
jmp 0x67bb5
movslq 0xa0(%rbx,%rdx,4), %rbx
leal -0x1(%rbx), %r10d
cmpl %r10d, %edi
jge 0x67bad
movq %r9, %r11
notq %r11
addq %rbx, %r11
shlq $0x3, %r9
leaq (%r9,%rsi,8), %rbx
addq %rcx, %rbx
xorl %r14d, %r14d
cmpq %r8, (%rbx,%r14,8)
setg %r9b
jg 0x67bb2
incq %r14
cmpq %r14, %r11
jne 0x67b94
movl %r10d, %edi
jmp 0x67bb5
decl %edi
xorl %r9d, %r9d
jmp 0x67bb8
addl %r14d, %edi
movq %r15, %r11
testb %r9b, %r9b
movq 0x8(%rsp), %r10
jne 0x67bcc
movl 0xa0(%r10,%rdx,4), %edi
decl %edi
movl %edi, 0x140(%rsp,%rdx,4)
movslq 0xa0(%r10,%rdx,4), %rdi
addq %rdi, %rsi
incq %rdx
cmpq %rbp, %rdx
jne 0x67b0d
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
movl $0x1, %ebx
movl $0x1, %edx
testw %bp, %bp
jle 0x67c50
leaq (,%rbp,4), %rdx
leaq 0xe0(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x3220
movq 0x8(%rsp), %r10
movq %r15, %r11
movl $0x1, %edx
xorl %eax, %eax
movl 0x140(%rsp,%rax,4), %ecx
subl 0x100(%rsp,%rax,4), %ecx
incl %ecx
movslq %ecx, %rcx
imulq %rcx, %rdx
incq %rax
cmpq %rax, %rbp
jne 0x67c31
testq %rdx, %rdx
jle 0x68405
leaq -0x1(%rbp), %rdi
movq 0x38(%rsp), %rax
addq %r11, %rax
addq $0x1e8, %rax # imm = 0x1E8
movq %rax, 0x80(%rsp)
leaq (%rbp,%rbp), %rax
movq %rax, 0x88(%rsp)
movq 0x18(%rsp), %r9
leaq (%r9,%rbp,8), %rax
movq %rax, 0x48(%rsp)
movl %ebp, %ecx
leaq (,%rcx,8), %rax
movq %rax, 0x40(%rsp)
leaq (,%rbp,8), %rax
movq %rax, 0x20(%rsp)
imulq $0x368, 0x10(%rsp), %rax # imm = 0x368
leaq (%r11,%rax), %r14
addq $0xd4ee0, %r14 # imm = 0xD4EE0
leaq (%r11,%rax), %rbx
addq $0xd50a8, %rbx # imm = 0xD50A8
leaq -0x1(%rcx), %rsi
movq %rsi, 0x58(%rsp)
shlq $0x2, %rcx
movq %rcx, 0x10(%rsp)
addq %rax, %r11
xorl %r8d, %r8d
movq %r11, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x90(%rsp)
testw %bp, %bp
jle 0x67d2e
movl $0x1, %edx
xorl %r15d, %r15d
xorl %eax, %eax
movq %rdx, %rcx
cmpq %rdi, %rax
jge 0x67d12
movslq (%r14,%rax,4), %rcx
imulq %rdx, %rcx
movslq 0xe0(%rsp,%rax,4), %rsi
imulq %rsi, %rdx
addq %rdx, %r15
incq %rax
movq %rcx, %rdx
cmpq %rax, %rbp
jne 0x67d05
jmp 0x67d31
xorl %r15d, %r15d
movq 0xd8(%rsp), %rcx
leal -0x1(%rcx), %eax
cmpl $0x3, %eax
movq %r8, 0x98(%rsp)
jae 0x67df5
movslq %r15d, %rax
cqto
idivq 0x260(%r10)
movl %edx, 0x60(%rsp)
cmpw $0x2, %bp
movq 0x58(%rsp), %rdi
jl 0x67d95
movl 0x60(%rsp), %edx
xorl %esi, %esi
movq %r15, %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rbx,%rsi,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rbx,%rsi,8)
movl %edx, 0x64(%rsp,%rsi,4)
incq %rsi
cmpq %rsi, %rdi
jne 0x67d71
testw %bp, %bp
movq 0x10(%rsp), %rdi
jle 0x6807b
xorl %eax, %eax
movslq 0x60(%rsp,%rax), %rcx
movq 0x188(%r14,%rax,2), %rdx
movq %rdx, %rsi
imulq %rcx, %rsi
incq %rsi
movq %rsi, 0x160(%rsp,%rax,2)
incq %rcx
imulq %rdx, %rcx
movq %rcx, 0xa0(%rsp,%rax,2)
movq -0x70(%r14,%rax,2), %rdx
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
movq %rcx, 0xa0(%rsp,%rax,2)
addq $0x4, %rax
cmpq %rax, %rdi
jne 0x67da5
jmp 0x6807b
cmpl $0x4, %ecx
je 0x67ebe
testl %ecx, %ecx
jne 0x6807b
movq 0x2a8(%r10), %rax
testq %rax, %rax
je 0x67f7b
cmpq %rax, %r15
jge 0x6803c
movl $0x1, %eax
testw %bp, %bp
jle 0x67e3b
xorl %ecx, %ecx
movslq (%r14,%rcx,4), %rdx
imulq %rdx, %rax
incq %rcx
cmpq %rcx, %rbp
jne 0x67e2b
testq %r15, %r15
js 0x6800f
cmpq %rax, %r15
jge 0x6800f
testw %bp, %bp
jle 0x6807b
movq 0x1e8(%r10), %rcx
xorl %esi, %esi
movq %r15, %rax
xorl %edi, %edi
movslq 0xd4ee0(%r11,%rsi,4), %r8
cqto
idivq %r8
leaq (%rcx,%rdx,8), %r9
movq (%r9,%rdi,8), %r10
movq %r10, 0x160(%rsp,%rsi,8)
leaq -0x1(%r8), %r10
cmpq %r10, %rdx
jne 0x67e94
movq 0xd4e70(%r11,%rsi,8), %rdx
jmp 0x67e9c
movq 0x8(%r9,%rdi,8), %rdx
decq %rdx
addq %r8, %rdi
movq %rdx, 0xa0(%rsp,%rsi,8)
incq %rsi
cmpq %rsi, %rbp
movq 0x18(%rsp), %r9
movq 0x8(%rsp), %r10
jne 0x67e64
jmp 0x6807b
movslq %r15d, %rax
cqto
idivq 0x260(%r10)
movl %edx, 0x60(%rsp)
cmpw $0x2, %bp
movq 0x58(%rsp), %rdi
jl 0x67f06
movl 0x60(%rsp), %edx
xorl %esi, %esi
movq %r15, %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rbx,%rsi,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rbx,%rsi,8)
movl %edx, 0x64(%rsp,%rsi,4)
incq %rsi
cmpq %rsi, %rdi
jne 0x67ee2
testw %bp, %bp
jle 0x6807b
movq 0x80(%rsp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x60(%rsp,%rcx), %rdi
movslq %edx, %rsi
addq %rdi, %rsi
movq (%rax,%rsi,8), %r8
movq %r8, 0x160(%rsp,%rcx,2)
movq 0x260(%r10,%rcx,2), %r8
decq %r8
cmpq %rdi, %r8
jle 0x67f56
movq 0x1e8(%r10), %rdi
movq 0x8(%rdi,%rsi,8), %rsi
decq %rsi
jmp 0x67f5b
movq 0x30(%r10,%rcx,2), %rsi
movq %rsi, 0xa0(%rsp,%rcx,2)
addl 0x260(%r10,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, 0x10(%rsp)
jne 0x67f1e
jmp 0x6807b
movl $0x1, %eax
testw %bp, %bp
jle 0x67f97
xorl %ecx, %ecx
movslq (%r14,%rcx,4), %rdx
imulq %rdx, %rax
incq %rcx
cmpq %rcx, %rbp
jne 0x67f87
testq %r15, %r15
js 0x6800f
cmpq %rax, %r15
jge 0x6800f
testw %bp, %bp
jle 0x6807b
movq 0x1e8(%r10), %rcx
xorl %esi, %esi
movq %r15, %rax
xorl %edi, %edi
movslq 0xd4ee0(%r11,%rsi,4), %r8
cqto
idivq %r8
leaq (%rcx,%rdx,8), %r9
movq (%r9,%rdi,8), %r10
movq %r10, 0x160(%rsp,%rsi,8)
leaq -0x1(%r8), %r10
cmpq %r10, %rdx
jne 0x67fe8
movq 0xd4e70(%r11,%rsi,8), %rdx
jmp 0x67ff0
movq 0x8(%r9,%rdi,8), %rdx
decq %rdx
addq %r8, %rdi
movq %rdx, 0xa0(%rsp,%rsi,8)
incq %rsi
cmpq %rsi, %rbp
movq 0x18(%rsp), %r9
movq 0x8(%rsp), %r10
jne 0x67fb8
jmp 0x6807b
testw %bp, %bp
jle 0x6807b
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
movq 0x20(%rsp), %rdx
callq 0x3170
leaq 0xa0(%rsp), %rdi
movl $0xff, %esi
movq 0x20(%rsp), %rdx
jmp 0x68067
testw %bp, %bp
jle 0x6807b
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
movq 0x40(%rsp), %rdx
callq 0x3170
leaq 0xa0(%rsp), %rdi
movl $0xff, %esi
movq 0x40(%rsp), %rdx
callq 0x3170
movq 0x8(%rsp), %r10
movq 0x30(%rsp), %r11
movq 0x18(%rsp), %r9
movq 0x28(%rsp), %rax
movq (%rax), %rax
imulq 0x88(%rsp), %rax
testw %bp, %bp
jle 0x680b7
leaq (%r9,%rax,8), %rcx
xorl %edx, %edx
movq (%r13,%rdx,8), %rsi
movq 0x160(%rsp,%rdx,8), %rdi
cmpq %rdi, %rsi
cmovgq %rsi, %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x68097
testw %bp, %bp
movq 0x98(%rsp), %r8
jle 0x680ee
movq 0x48(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
xorl %ecx, %ecx
movq (%r12,%rcx,8), %rdx
movq 0xa0(%rsp,%rcx,8), %rsi
cmpq %rsi, %rdx
cmovlq %rdx, %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x680cf
cmpq $0x0, 0x2a8(%r10)
movq 0x38(%rsp), %rdx
movq 0x90(%rsp), %rdi
je 0x68110
movq 0x2a0(%r10), %rax
movq (%rax,%r15,8), %r15
movq 0x50(%rsp), %rax
movq %r15, (%rax,%r8,8)
testw %bp, %bp
jle 0x68151
xorl %eax, %eax
movl 0xe0(%rsp,%rax,4), %ecx
cmpl 0x140(%rsp,%rax,4), %ecx
jl 0x68148
movl 0x100(%rsp,%rax,4), %ecx
movl %ecx, 0xe0(%rsp,%rax,4)
incq %rax
cmpq %rax, %rbp
jne 0x68120
jmp 0x68151
incl %ecx
movl %ecx, 0xe0(%rsp,%rax,4)
movq 0x28(%rsp), %rax
incq (%rax)
incq %r8
cmpq %rdx, %r8
jne 0x67cf3
jmp 0x68400
movq 0x298(%r10), %rbx
testq %rbx, %rbx
jle 0x68357
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x10(%rsp), %rdi
movq %r15, %rsi
leaq 0x160(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
callq 0x5f51f
testw %bp, %bp
jle 0x681f2
movl $0x1, %eax
movq 0x158(%rsp,%rax,8), %rdx
movq -0x8(%r13,%rax,8), %rcx
cmpq %rcx, %rdx
jl 0x681c0
cmpq -0x8(%r12,%rax,8), %rdx
jle 0x681da
movq 0x98(%rsp,%rax,8), %rdx
cmpq %rcx, %rdx
jl 0x681d4
cmpq -0x8(%r12,%rax,8), %rdx
jle 0x681da
movb $0x1, %cl
xorl %edx, %edx
jmp 0x681de
movb $0x1, %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x681ee
leaq 0x1(%rax), %rdx
cmpq %rbp, %rax
movq %rdx, %rax
jl 0x681a7
testb %cl, %cl
jne 0x681fe
movq 0x50(%rsp), %rax
movq %r15, (%rax,%r14,8)
incq %r14
incq %r15
cmpq %rbx, %r15
jne 0x68180
jmp 0x6835a
leaq -0x1(%rbp), %rcx
movq 0xa0(%rsp), %rsi
imulq $0x368, 0x10(%rsp), %rdi # imm = 0x368
leaq 0xd5098(%rdi), %rdx
movq %rdx, 0x8(%rsp)
movq %rbp, %r9
shlq $0x4, %r9
xorl %edx, %edx
testw %bp, %bp
jle 0x68269
movq (%r14), %r11
addq 0x8(%rsp), %r11
movl $0x1, %r15d
movq %rbp, %r12
xorl %ebx, %ebx
imulq %r15, %rbx
addq 0xf8(%rsp,%r12,8), %rbx
imulq (%r11,%r12,8), %r15
decq %r12
jg 0x68251
jmp 0x6826b
xorl %ebx, %ebx
movq 0x50(%rsp), %r8
movq %rbx, (%r8,%rdx,8)
testw %bp, %bp
jle 0x682d8
movq 0x18(%rsp), %r11
movq %rdi, %rbx
leaq 0x100(%rsp), %r15
movq %rbp, %r12
movq (%r15), %r13
movq (%r14), %r10
movq 0xd5068(%r10,%rbx), %r8
imulq %r13, %r8
incq %r8
movq %r8, (%r11)
incq %r13
imulq 0xd5068(%r10,%rbx), %r13
movq %r13, (%r11,%rbp,8)
movq 0xd4e70(%r10,%rbx), %r8
cmpq %r8, %r13
cmovgeq %r8, %r13
movq %r13, (%r11,%rbp,8)
addq $0x8, %r15
addq $0x8, %rbx
addq $0x8, %r11
decq %r12
jne 0x6828c
movq 0x100(%rsp), %r11
leaq 0x1(%r11), %r8
movq %r8, 0x100(%rsp)
testw %bp, %bp
jle 0x68334
cmpq %rsi, %r11
jl 0x68334
xorl %r11d, %r11d
cmpq %rcx, %r11
jge 0x68316
movq 0x160(%rsp,%r11,8), %r8
movq %r8, 0x100(%rsp,%r11,8)
incq 0x108(%rsp,%r11,8)
leaq 0x1(%r11), %rbx
cmpq %rbp, %rbx
jge 0x68334
movq 0xa8(%rsp,%r11,8), %r8
cmpq %r8, 0x108(%rsp,%r11,8)
movq %rbx, %r11
jg 0x682f9
incq %rdx
addq %r9, 0x18(%rsp)
cmpq %rax, 0xf8(%rsp,%rbp,8)
jle 0x68239
movq 0x28(%rsp), %rax
movq %rdx, (%rax)
jmp 0x68400
xorl %r14d, %r14d
movq 0x28(%rsp), %rax
movq %r14, (%rax)
testq %r14, %r14
jle 0x68400
movq %rbp, %rbx
shlq $0x4, %rbx
leaq (,%rbp,8), %rax
movq %rax, 0x8(%rsp)
xorl %r15d, %r15d
movq 0x50(%rsp), %rax
movq (%rax,%r15,8), %rsi
movq 0x10(%rsp), %rdi
leaq 0x160(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
callq 0x5f51f
testw %bp, %bp
movq 0x18(%rsp), %rdi
jle 0x683f0
movq 0x8(%rsp), %rax
addq %rdi, %rax
xorl %ecx, %ecx
movq (%r13,%rcx,8), %rdx
movq 0x160(%rsp,%rcx,8), %rsi
cmpq %rsi, %rdx
cmovgq %rdx, %rsi
movq %rsi, (%rdi,%rcx,8)
movq (%r12,%rcx,8), %rdx
movq 0xa0(%rsp,%rcx,8), %rsi
cmpq %rsi, %rdx
cmovlq %rdx, %rsi
movq %rsi, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbp
jne 0x683b9
incq %r15
addq %rbx, %rdi
movq %rdi, 0x18(%rsp)
cmpq %r14, %r15
jne 0x68382
movl $0x1, %ebx
movq %rbx, %rax
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_get_distribution_type | void pnga_get_distribution_type(Integer g_a, char *type)
{
Integer ga_handle = GA_OFFSET + g_a;
Integer itype = GA[ga_handle].distr_type;
if (itype == REGULAR) {
strcpy(type,"regular");
} else if (itype == BLOCK_CYCLIC) {
strcpy(type,"block_cyclic");
} else if (itype == SCALAPACK) {
strcpy(type,"scalapack");
} else if (itype == TILED) {
strcpy(type,"tiled");
} else if (itype == TILED_IRREG) {
strcpy(type,"tiled_irreg");
} else {
strcpy(type,"unknown");
}
} | leaq 0x74383(%rip), %rax # 0xdc8b8
movq (%rax), %rax
imulq $0x368, %rdi, %rcx # imm = 0x368
movl 0xd5064(%rax,%rcx), %eax
cmpq $0x4, %rax
ja 0x685b8
leaq 0x50c41(%rip), %rcx # 0xb9194
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x72616c75676572, %rax # imm = 0x72616C75676572
jmp 0x685c2
movabsq $0x72695f64656c6974, %rax # imm = 0x72695F64656C6974
movq %rax, (%rsi)
movl $0x676572, 0x8(%rsi) # imm = 0x676572
retq
movabsq $0x636170616c616373, %rax # imm = 0x636170616C616373
movq %rax, (%rsi)
movw $0x6b, 0x8(%rsi)
retq
movw $0x64, 0x4(%rsi)
movl $0x656c6974, (%rsi) # imm = 0x656C6974
retq
movabsq $0x63696c6379635f, %rax # imm = 0x63696C6379635F
movq %rax, 0x5(%rsi)
movabsq $0x79635f6b636f6c62, %rax # imm = 0x79635F6B636F6C62
jmp 0x685c2
movabsq $0x6e776f6e6b6e75, %rax # imm = 0x6E776F6E6B6E75
movq %rax, (%rsi)
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_pgroup_absolute_id | Integer pnga_pgroup_absolute_id(Integer grp, Integer pid)
{
#ifdef MSG_COMMS_MPI
if(grp == GA_World_Proc_Group) /*a.k.a -1*/
return pid;
else
return ARMCI_Absolute_id(&PGRP_LIST[grp].group, pid);
#else
pnga_error("ga_pgroup_absolute_id(): Defined only when using MPI groups",0);
return -1;
#endif
} | leaq 0x6db05(%rip), %rax # 0xd716c
movslq (%rax), %rax
cmpq %rdi, %rax
je 0x69692
pushq %rax
leaq 0x73299(%rip), %rax # 0xdc910
movq (%rax), %rax
leaq (%rdi,%rdi,4), %rcx
leaq (%rax,%rcx,8), %rdi
addq $0x20, %rdi
callq 0x5909a
movslq %eax, %rsi
addq $0x8, %rsp
movq %rsi, %rax
retq
| /GlobalArrays[P]ga/global/src/base.c |
pnga_nbwait_notify | void pnga_nbwait_notify(Integer *nbhandle)
{
int i;
for (i = 0; i < HANDLES_OUTSTANDING; i++)
if (putn_handles[i].orighdl == nbhandle)
break;
if (i >= HANDLES_OUTSTANDING)
return; /* Incorrect handle used or maybe wait was called multiple times? */
nga_wait_internal(&putn_handles[i].firsthdl);
nga_wait_internal(&putn_handles[i].elementhdl);
if (putn_handles[i].elem_copy) {
free(putn_handles[i].elem_copy);
putn_handles[i].elem_copy = NULL;
}
putn_handles[i].orighdl = NULL;
} | pushq %r15
pushq %r14
pushq %rbx
leaq 0x73adb(%rip), %rcx # 0xddda0
xorl %eax, %eax
cmpq %rdi, (%rcx)
je 0x6a2de
incq %rax
addq $0x20, %rcx
cmpq $0x64, %rax
jne 0x6a2c7
movl $0x64, %eax
cmpl $0x63, %eax
ja 0x6a32d
movl %eax, %ebx
shlq $0x5, %rbx
leaq 0x73ab0(%rip), %r15 # 0xddda0
leaq (%r15,%rbx), %r14
leaq (%rbx,%r15), %rdi
addq $0x8, %rdi
callq 0x99d72
addq %r15, %rbx
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x99d72
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6a326
callq 0x3330
movq $0x0, 0x18(%r14)
movq $0x0, (%r14)
popq %rbx
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/onesided.c |
pnga_access_block_ptr | void pnga_access_block_ptr(Integer g_a, Integer idx, void* ptr, Integer *ld)
/* g_a: array handle [input]
* idx: block index [input]
* ptr: pointer to data in block [output]
* ld: array of strides for block data [output]
*/
{
char *lptr;
Integer handle = GA_OFFSET + g_a;
Integer i, j/*, p_handle*/, nblocks, offset, tsum, inode;
Integer ndim, lo[MAXDIM], hi[MAXDIM], index;
/*p_handle = GA[handle].p_handle;*/
nblocks = GA[handle].block_total;
ndim = GA[handle].ndim;
index = idx;
if (index < 0 || index >= nblocks)
pnga_error("block index outside allowed values",index);
if (GA[handle].distr_type == BLOCK_CYCLIC) {
offset = 0;
inode = index%GAnproc;
for (i=inode; i<index; i += GAnproc) {
ga_ownsM(handle,i,lo,hi);
tsum = 1;
for (j=0; j<ndim; j++) {
tsum *= (hi[j]-lo[j]+1);
}
offset += tsum;
}
lptr = GA[handle].ptr[inode]+offset*GA[handle].elemsize;
ga_ownsM(handle,index,lo,hi);
for (i=0; i<ndim-1; i++) {
ld[i] = hi[i]-lo[i]+1;
}
} else if (GA[handle].distr_type == SCALAPACK ||
GA[handle].distr_type == TILED ||
GA[handle].distr_type == TILED_IRREG) {
Integer indices[MAXDIM];
/* find block indices */
gam_find_block_indices(handle,index,indices);
/* find pointer */
pnga_access_block_grid_ptr(g_a, indices, &lptr, ld);
}
*(char**)ptr = lptr;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x3e8(%rdi), %rcx
leaq 0x70217(%rip), %r14 # 0xdc8b8
movq (%r14), %rax
imulq $0x368, %rcx, %rbp # imm = 0x368
movswq (%rax,%rbp), %rbx
testq %rsi, %rsi
js 0x6c6c1
addq %rbp, %rax
cmpq %r15, 0x298(%rax)
jg 0x6c6d0
leaq 0x4ddd9(%rip), %rdi # 0xba4a1
movq %r15, %rsi
callq 0x18f07
movq (%r14), %rcx
movq %rcx, (%rsp)
movl 0x224(%rcx,%rbp), %eax
leal -0x2(%rax), %ecx
cmpl $0x3, %ecx
movq %rbp, %rsi
jae 0x6c770
movq (%rsp), %rdi
movswq (%rdi,%rsi), %rcx
movslq %r15d, %rax
cqto
idivq 0x260(%rdi,%rsi)
movq %rdx, 0x60(%rsp)
cmpq $0x2, %rcx
movq 0x8(%rsp), %rdi
jl 0x6c759
movq 0x60(%rsp), %rdx
imulq $0x368, %rdi, %rax # imm = 0x368
movq (%rsp), %rsi
addq %rax, %rsi
addq $0xd50a8, %rsi # imm = 0xD50A8
decq %rcx
xorl %r8d, %r8d
movslq %r15d, %rax
subq %rdx, %rax
cqto
idivq -0x8(%rsi,%r8,8)
movq %rax, %r15
movslq %r15d, %rax
cqto
idivq (%rsi,%r8,8)
movq %rdx, 0x68(%rsp,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0x6c733
leaq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %r13, %rcx
callq 0x6bdea
jmp 0x6cf68
cmpl $0x1, %eax
jne 0x6cf68
movq %r13, 0x40(%rsp)
movq %r12, 0x48(%rsp)
leaq 0x7020e(%rip), %rax # 0xdc998
movq (%rax), %rcx
movq %r15, %rax
cqto
movq %rcx, 0x100(%rsp)
idivq %rcx
cmpq %r15, %rdx
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
jge 0x6cb55
movq (%rsp), %rcx
leaq (%rcx,%rsi), %r14
leaq (%rcx,%rsi), %rax
addq $0x1e8, %rax # imm = 0x1E8
movq %rax, 0xf0(%rsp)
movl 0x3c(%rax), %eax
imulq $0x368, 0x8(%rsp), %r11 # imm = 0x368
leaq (%rcx,%r11), %r12
addq $0xd50a8, %r12 # imm = 0xD50A8
addq %rcx, %r11
xorl %esi, %esi
movq %rax, 0xf8(%rsp)
decl %eax
movl %eax, 0x3c(%rsp)
movq %rdx, %r13
movq %r11, 0x30(%rsp)
cmpl $0x3, 0x3c(%rsp)
movq %rsi, 0x50(%rsp)
jae 0x6c8bc
movswl (%r14), %edi
movslq %r13d, %rax
cqto
idivq 0x260(%r14)
movl %edx, 0x10(%rsp)
movl %edi, %esi
cmpl $0x2, %edi
jl 0x6c860
movl 0x10(%rsp), %edx
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq %r13, %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%r12,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%r12,%r9,8)
movl %edx, 0x14(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x6c83b
testw %di, %di
jle 0x6cb0b
shlq $0x2, %rsi
xorl %eax, %eax
movslq 0x10(%rsp,%rax), %rcx
movq -0x40(%r12,%rax,2), %rdx
movq %rdx, %rdi
imulq %rcx, %rdi
incq %rdi
movq %rdi, 0x60(%rsp,%rax,2)
incq %rcx
imulq %rdx, %rcx
movq %rcx, 0xa0(%rsp,%rax,2)
movq -0x238(%r12,%rax,2), %rdx
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
movq %rcx, 0xa0(%rsp,%rax,2)
addq $0x4, %rax
cmpq %rax, %rsi
jne 0x6c86f
jmp 0x6cb0b
movq 0xf8(%rsp), %rax
cmpl $0x4, %eax
je 0x6c988
testl %eax, %eax
jne 0x6cb0b
movq 0x2a8(%r14), %rax
testq %rax, %rax
je 0x6ca4a
movswq (%r14), %rbp
cmpq %rax, %r13
jge 0x6cad9
movl $0x1, %eax
testw %bp, %bp
jle 0x6c912
xorl %ecx, %ecx
movslq -0x1c8(%r12,%rcx,4), %rdx
imulq %rdx, %rax
incq %rcx
cmpq %rcx, %rbp
jne 0x6c8fe
testq %r13, %r13
js 0x6cad9
cmpq %rax, %r13
jge 0x6cad9
testw %bp, %bp
jle 0x6cb0b
movq 0x1e8(%r14), %rcx
xorl %esi, %esi
movq %r13, %rax
xorl %edi, %edi
movslq 0xd4ee0(%r11,%rsi,4), %r8
cqto
idivq %r8
leaq (%rcx,%rdx,8), %r9
movq (%r9,%rdi,8), %r10
movq %r10, 0x60(%rsp,%rsi,8)
leaq -0x1(%r8), %r10
cmpq %r10, %rdx
jne 0x6c968
movq 0xd4e70(%r11,%rsi,8), %rdx
jmp 0x6c970
movq 0x8(%r9,%rdi,8), %rdx
decq %rdx
addq %r8, %rdi
movq %rdx, 0xa0(%rsp,%rsi,8)
incq %rsi
cmpq %rsi, %rbp
jne 0x6c93b
jmp 0x6cb0b
movswl (%r14), %edi
movslq %r13d, %rax
cqto
idivq 0x260(%r14)
movl %edx, 0x10(%rsp)
movl %edi, %esi
cmpl $0x2, %edi
jl 0x6c9d6
movl 0x10(%rsp), %edx
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq %r13, %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%r12,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%r12,%r9,8)
movl %edx, 0x14(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x6c9b1
testw %di, %di
jle 0x6cb0b
movq 0xf0(%rsp), %rax
movq (%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x10(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x60(%rsp,%rcx,2)
movq 0x260(%r14,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x6ca27
movq 0x1e8(%r14), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x6ca2c
movq 0x30(%r14,%rcx,2), %rdi
movq %rdi, 0xa0(%rsp,%rcx,2)
addl 0x260(%r14,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x6c9f2
jmp 0x6cb0b
movswq (%r14), %rbp
movl $0x1, %eax
testq %rbp, %rbp
jle 0x6ca6e
xorl %ecx, %ecx
movslq -0x1c8(%r12,%rcx,4), %rdx
imulq %rdx, %rax
incq %rcx
cmpq %rcx, %rbp
jne 0x6ca5a
testq %r13, %r13
js 0x6cad9
cmpq %rax, %r13
jge 0x6cad9
testw %bp, %bp
jle 0x6cb0b
movq 0x1e8(%r14), %rcx
xorl %esi, %esi
movq %r13, %rax
xorl %edi, %edi
movslq 0xd4ee0(%r11,%rsi,4), %r8
cqto
idivq %r8
leaq (%rcx,%rdx,8), %r9
movq (%r9,%rdi,8), %r10
movq %r10, 0x60(%rsp,%rsi,8)
leaq -0x1(%r8), %r10
cmpq %r10, %rdx
jne 0x6cabc
movq 0xd4e70(%r11,%rsi,8), %rdx
jmp 0x6cac4
movq 0x8(%r9,%rdi,8), %rdx
decq %rdx
addq %r8, %rdi
movq %rdx, 0xa0(%rsp,%rsi,8)
incq %rsi
cmpq %rsi, %rbp
jne 0x6ca8f
jmp 0x6cb0b
testw %bp, %bp
jle 0x6cb0b
shlq $0x3, %rbp
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3170
leaq 0xa0(%rsp), %rdi
movl $0xff, %esi
movq %rbp, %rdx
callq 0x3170
movq 0x30(%rsp), %r11
movl $0x1, %eax
testw %bx, %bx
jle 0x6cb3a
xorl %ecx, %ecx
movq 0x50(%rsp), %rsi
movq 0xa0(%rsp,%rcx,8), %rdx
subq 0x60(%rsp,%rcx,8), %rdx
incq %rdx
imulq %rdx, %rax
incq %rcx
cmpq %rcx, %rbx
jne 0x6cb1c
jmp 0x6cb3f
movq 0x50(%rsp), %rsi
addq %rax, %rsi
addq 0x100(%rsp), %r13
cmpq %r15, %r13
jl 0x6c802
jmp 0x6cb57
xorl %esi, %esi
movq 0xe8(%rsp), %r13
movq (%rsp), %rdi
leaq (%rdi,%r13), %rcx
movq 0x1e0(%rdi,%r13), %rax
movslq 0x18(%rdi,%r13), %rdx
imulq %rsi, %rdx
movq 0xe0(%rsp), %rsi
addq (%rax,%rsi,8), %rdx
movq %rdx, 0x58(%rsp)
movl 0x224(%rdi,%r13), %eax
leal -0x1(%rax), %edx
cmpl $0x3, %edx
jae 0x6cc7a
movswl (%rcx), %esi
movslq %r15d, %rax
cqto
idivq 0x260(%rcx)
movl %edx, 0x10(%rsp)
movl %esi, %ecx
cmpl $0x2, %esi
movq 0x48(%rsp), %r12
movq 0x40(%rsp), %r14
jl 0x6cc09
movl 0x10(%rsp), %edx
imulq $0x368, 0x8(%rsp), %rax # imm = 0x368
movq (%rsp), %rdi
addq %rax, %rdi
addq $0xd50a8, %rdi # imm = 0xD50A8
leaq -0x1(%rcx), %r8
xorl %r9d, %r9d
subl %edx, %r15d
movslq %r15d, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %r15
movslq %r15d, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x14(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x6cbe3
testw %si, %si
jle 0x6cf41
imulq $0x368, 0x8(%rsp), %rax # imm = 0x368
movq (%rsp), %rdx
addq %rdx, %rax
addq $0xd5068, %rax # imm = 0xD5068
shlq $0x2, %rcx
xorl %edx, %edx
movslq 0x10(%rsp,%rdx), %rsi
movq (%rax,%rdx,2), %rdi
movq %rdi, %r8
imulq %rsi, %r8
incq %r8
movq %r8, 0x60(%rsp,%rdx,2)
incq %rsi
imulq %rdi, %rsi
movq %rsi, 0xa0(%rsp,%rdx,2)
movq -0x1f8(%rax,%rdx,2), %rdi
cmpq %rdi, %rsi
cmovgeq %rdi, %rsi
movq %rsi, 0xa0(%rsp,%rdx,2)
addq $0x4, %rdx
cmpq %rdx, %rcx
jne 0x6cc2e
jmp 0x6cf41
cmpl $0x4, %eax
movq 0x48(%rsp), %r12
movq 0x40(%rsp), %r14
je 0x6ccea
testl %eax, %eax
jne 0x6cf41
movq 0x2a8(%rcx), %rax
testq %rax, %rax
je 0x6cdc0
movswq (%rcx), %rbp
cmpq %r15, %rax
jle 0x6cf14
testw %bp, %bp
jle 0x6ce8c
imulq $0x368, 0x8(%rsp), %rax # imm = 0x368
movq (%rsp), %rdx
addq %rax, %rdx
addq $0xd4ee0, %rdx # imm = 0xD4EE0
movl $0x1, %eax
xorl %esi, %esi
movslq (%rdx,%rsi,4), %rdi
imulq %rdi, %rax
incq %rsi
cmpq %rsi, %rbp
jne 0x6ccd5
jmp 0x6ce91
movswl (%rcx), %edi
movslq %r15d, %rax
cqto
idivq 0x260(%rcx)
movl %edx, 0x10(%rsp)
movl %edi, %esi
cmpl $0x2, %edi
jl 0x6cd4c
movl 0x10(%rsp), %edx
imulq $0x368, 0x8(%rsp), %rax # imm = 0x368
movq (%rsp), %r8
addq %rax, %r8
addq $0xd50a8, %r8 # imm = 0xD50A8
leaq -0x1(%rsi), %r9
xorl %r10d, %r10d
subl %edx, %r15d
movslq %r15d, %rax
cqto
idivq -0x8(%r8,%r10,8)
movq %rax, %r15
movslq %r15d, %rax
cqto
idivq (%r8,%r10,8)
movl %edx, 0x14(%rsp,%r10,4)
incq %r10
cmpq %r10, %r9
jne 0x6cd26
testw %di, %di
jle 0x6cf41
movq (%rsp), %rax
movq 0x1e8(%rax,%r13), %rax
shlq $0x2, %rsi
xorl %edx, %edx
xorl %edi, %edi
movslq 0x10(%rsp,%rdx), %r9
movslq %edi, %r8
addq %r9, %r8
movq (%rax,%r8,8), %r10
movq %r10, 0x60(%rsp,%rdx,2)
movq 0x260(%rcx,%rdx,2), %r10
decq %r10
cmpq %r9, %r10
jle 0x6cd9e
movq 0x1e8(%rcx), %r9
movq 0x8(%r9,%r8,8), %r8
decq %r8
jmp 0x6cda3
movq 0x30(%rcx,%rdx,2), %r8
movq %r8, 0xa0(%rsp,%rdx,2)
addl 0x260(%rcx,%rdx,2), %edi
addq $0x4, %rdx
cmpq %rdx, %rsi
jne 0x6cd69
jmp 0x6cf41
movswq (%rcx), %rbp
testq %rbp, %rbp
jle 0x6cdf9
imulq $0x368, 0x8(%rsp), %rax # imm = 0x368
movq (%rsp), %rdx
addq %rax, %rdx
addq $0xd4ee0, %rdx # imm = 0xD4EE0
movl $0x1, %eax
xorl %esi, %esi
movslq (%rdx,%rsi,4), %rdi
imulq %rdi, %rax
incq %rsi
cmpq %rsi, %rbp
jne 0x6cde7
jmp 0x6cdfe
movl $0x1, %eax
testq %r15, %r15
js 0x6cf14
cmpq %r15, %rax
jle 0x6cf14
testw %bp, %bp
jle 0x6cf41
movq 0x1e8(%rcx), %rcx
imulq $0x368, 0x8(%rsp), %rax # imm = 0x368
addq %rax, (%rsp)
xorl %esi, %esi
xorl %edi, %edi
movq (%rsp), %rax
movslq 0xd4ee0(%rax,%rdi,4), %r8
movq %r15, %rax
cqto
idivq %r8
leaq (%rcx,%rdx,8), %r9
movq (%r9,%rsi,8), %r10
movq %r10, 0x60(%rsp,%rdi,8)
leaq -0x1(%r8), %r10
movq %rax, %r15
cmpq %r10, %rdx
jne 0x6ce6c
movq (%rsp), %rax
movq 0xd4e70(%rax,%rdi,8), %rax
jmp 0x6ce74
movq 0x8(%r9,%rsi,8), %rax
decq %rax
addq %r8, %rsi
movq %rax, 0xa0(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %rbp
jne 0x6ce31
jmp 0x6cf41
movl $0x1, %eax
testq %r15, %r15
js 0x6cf14
cmpq %r15, %rax
jle 0x6cf14
testw %bp, %bp
jle 0x6cf41
movq 0x1e8(%rcx), %rcx
imulq $0x368, 0x8(%rsp), %rax # imm = 0x368
addq %rax, (%rsp)
xorl %esi, %esi
xorl %edi, %edi
movq (%rsp), %rax
movslq 0xd4ee0(%rax,%rdi,4), %r8
movq %r15, %rax
cqto
idivq %r8
leaq (%rcx,%rdx,8), %r9
movq (%r9,%rsi,8), %r10
movq %r10, 0x60(%rsp,%rdi,8)
leaq -0x1(%r8), %r10
movq %rax, %r15
cmpq %r10, %rdx
jne 0x6cef7
movq (%rsp), %rax
movq 0xd4e70(%rax,%rdi,8), %rax
jmp 0x6ceff
movq 0x8(%r9,%rsi,8), %rax
decq %rax
addq %r8, %rsi
movq %rax, 0xa0(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %rbp
jne 0x6cebc
jmp 0x6cf41
testw %bp, %bp
jle 0x6cf41
shlq $0x3, %rbp
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3170
leaq 0xa0(%rsp), %rdi
movl $0xff, %esi
movq %rbp, %rdx
callq 0x3170
cmpw $0x2, %bx
jl 0x6cf68
decq %rbx
xorl %eax, %eax
movq 0xa0(%rsp,%rax,8), %rcx
subq 0x60(%rsp,%rax,8), %rcx
incq %rcx
movq %rcx, (%r14,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0x6cf4c
movq 0x58(%rsp), %rax
movq %rax, (%r12)
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/onesided.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 */
Integer *map; /* map the active processes to allocated space */
char *buf1, *buf2;
Integer handle = g_a + GA_OFFSET;
Integer *count; /* counters for each process */
Integer *nelem; /* number of elements for each process */
/* source and destination pointers for each process */
void ***ptr_src, ***ptr_dst;
void **ptr_org; /* the entire pointer array */
armci_giov_t desc;
Integer *ilo, *ihi, *jlo, *jhi, *ldp, *owner;
Integer lo[2], hi[2];
char **ptr_ref;
Integer num_blocks=0;
if (nv < 1) return;
ga_check_handleM(g_a, "ga_scatter");
GAstat.numsca++;
/* determine how many processors are associated with array */
p_handle = GA[handle].p_handle;
if (p_handle < 0) {
nproc = GAnproc;
if (GA[handle].num_rstrctd > 0) {
nproc = GA[handle].num_rstrctd;
}
} else {
nproc = PGRP_LIST[p_handle].map_nproc;
}
/* allocate temp memory */
if (GA[handle].distr_type == REGULAR) {
buf1 = malloc((int) (nproc *4 +nv)* (sizeof(Integer)));
if(buf1 == NULL) pnga_error("malloc failed", 3*nproc);
} else {
num_blocks = GA[handle].block_total;
buf1 = malloc((int) (num_blocks *4 +nv)* (sizeof(Integer)));
if(buf1 == NULL) pnga_error("malloc failed", 3*num_blocks);
}
owner = (Integer *)buf1;
count = owner+ nv;
if (GA[handle].distr_type == REGULAR) {
nelem = count + nproc;
aproc = count + 2 * nproc;
map = count + 3 * nproc;
} else {
nelem = count + num_blocks;
aproc = count + 2 * num_blocks;
map = count + 3 * num_blocks;
}
/* initialize the counters and nelem */
if (GA[handle].distr_type == REGULAR) {
for(kk=0; kk<nproc; kk++) {
count[kk] = 0; nelem[kk] = 0;
}
} else {
for(kk=0; kk<num_blocks; kk++) {
count[kk] = 0; nelem[kk] = 0;
}
}
/* find proc that owns the (i,j) element; store it in temp: */
if (GA[handle].num_rstrctd == 0) {
for(k=0; k< nv; k++) {
subscrpt[0] = *(i+k);
subscrpt[1] = *(j+k);
if(! pnga_locate(g_a, subscrpt, owner+k)){
char err_string[ERR_STR_LEN];
sprintf(err_string,"invalid i/j=(%ld,%ld)", (long)i[k], (long)j[k]);
pnga_error(err_string,g_a);
}
iproc = owner[k];
nelem[iproc]++;
}
} else {
for(k=0; k< nv; k++) {
subscrpt[0] = *(i+k);
subscrpt[1] = *(j+k);
if(! pnga_locate(g_a, subscrpt, owner+k)){
char err_string[ERR_STR_LEN];
sprintf(err_string,"invalid i/j=(%ld,%ld)", (long)i[k], (long)j[k]);
pnga_error(err_string,g_a);
}
iproc = GA[handle].rank_rstrctd[owner[k]];
nelem[iproc]++;
}
}
naproc = 0;
if (GA[handle].distr_type == REGULAR) {
for(k=0; k<nproc; k++) if(nelem[k] > 0) {
aproc[naproc] = k;
map[k] = naproc;
naproc ++;
}
} else {
for(k=0; k<num_blocks; k++) if(nelem[k] > 0) {
aproc[naproc] = k;
map[k] = naproc;
naproc ++;
}
}
GAstat.numsca_procs += naproc;
buf2 = malloc((int)(2*naproc*sizeof(void **) + 2*nv*sizeof(void *) +
5*naproc*sizeof(Integer) + naproc*sizeof(char*)));
if(buf2 == NULL) pnga_error("malloc failed", naproc);
ptr_src = (void ***)buf2;
ptr_dst = (void ***)(buf2 + naproc*sizeof(void **));
ptr_org = (void **)(buf2 + 2*naproc*sizeof(void **));
ptr_ref = (char **)(buf2+2*naproc*sizeof(void **)+2*nv*sizeof(void *));
ilo = (Integer *)(((char*)ptr_ref) + naproc*sizeof(char*));
ihi = ilo + naproc;
jlo = ihi + naproc;
jhi = jlo + naproc;
ldp = jhi + naproc;
if (GA[handle].distr_type == REGULAR) {
for(kk=0; kk<naproc; kk++) {
iproc = aproc[kk];
if (GA[handle].num_rstrctd > 0)
iproc = GA[handle].rstrctd_list[iproc];
pnga_distribution(g_a, iproc, lo, hi);
ilo[kk] = lo[0];
jlo[kk] = lo[1];
ihi[kk] = hi[0];
jhi[kk] = hi[1];
/* get address of the first element owned by proc */
gaShmemLocation(aproc[kk], g_a, ilo[kk], jlo[kk], &(ptr_ref[kk]),
&(ldp[kk]));
}
} else {
for(kk=0; kk<naproc; kk++) {
iproc = aproc[kk];
pnga_distribution(g_a, iproc, lo, hi);
ilo[kk] = lo[0];
jlo[kk] = lo[1];
ihi[kk] = hi[0];
jhi[kk] = hi[1];
/* get address of the first element owned by proc */
pnga_access_block_ptr(g_a, iproc, &(ptr_ref[kk]), &(ldp[kk]));
pnga_release_block(g_a, iproc);
}
}
/* determine limit for message size -- v,i, & j will travel together */
item_size = GAsizeofM(type);
GAbytes.scatot += (double)item_size*nv ;
iproc = owner[GAme];
GAbytes.scaloc += (double)item_size* nelem[iproc];
ptr_src[0] = ptr_org; ptr_dst[0] = ptr_org + nv;
for(k=1; k<naproc; k++) {
ptr_src[k] = ptr_src[k-1] + nelem[aproc[k-1]];
ptr_dst[k] = ptr_dst[k-1] + nelem[aproc[k-1]];
}
for(k=0; k<nv; k++){
Integer this_count;
proc = owner[k];
if (GA[handle].num_rstrctd > 0)
proc = GA[handle].rank_rstrctd[owner[k]];
this_count = count[proc];
count[proc]++;
proc = map[proc];
ptr_src[proc][this_count] = ((char*)v) + k * item_size;
if(i[k] < ilo[proc] || i[k] > ihi[proc] ||
j[k] < jlo[proc] || j[k] > jhi[proc]){
char err_string[ERR_STR_LEN];
sprintf(err_string,"proc=%d invalid i/j=(%ld,%ld)><[%ld:%ld,%ld:%ld]",
(int)proc, (long)i[k], (long)j[k], (long)ilo[proc],
(long)ihi[proc], (long)jlo[proc], (long)jhi[proc]);
pnga_error(err_string, g_a);
}
ptr_dst[proc][this_count] = ptr_ref[proc] + item_size *
((j[k] - jlo[proc])* ldp[proc] + i[k] - ilo[proc]);
}
/* source and destination pointers are ready for all processes */
if (GA[handle].distr_type == REGULAR) {
for(k=0; k<naproc; k++) {
int rc;
desc.bytes = (int)item_size;
desc.src_ptr_array = ptr_src[k];
desc.dst_ptr_array = ptr_dst[k];
desc.ptr_array_len = (int)nelem[aproc[k]];
if (p_handle < 0) {
iproc = aproc[k];
if (GA[handle].num_rstrctd > 0)
iproc = GA[handle].rstrctd_list[iproc];
} else {
iproc = PGRP_LIST[p_handle].inv_map_proc_list[aproc[k]];
}
rc = ARMCI_PutV(&desc, 1, (int)iproc);
if(rc) pnga_error("scatter failed in armci",rc);
}
} else if (GA[handle].distr_type == BLOCK_CYCLIC) {
for(k=0; k<naproc; k++) {
int rc;
desc.bytes = (int)item_size;
desc.src_ptr_array = ptr_src[k];
desc.dst_ptr_array = ptr_dst[k];
desc.ptr_array_len = (int)nelem[aproc[k]];
iproc = aproc[k];
iproc = iproc%nproc;
if (p_handle >= 0) {
iproc = PGRP_LIST[p_handle].inv_map_proc_list[iproc];
}
rc = ARMCI_PutV(&desc, 1, (int)iproc);
if(rc) pnga_error("scatter failed in armci",rc);
}
} else if (GA[handle].distr_type == SCALAPACK) {
Integer index[MAXDIM];
for(k=0; k<naproc; k++) {
int rc;
desc.bytes = (int)item_size;
desc.src_ptr_array = ptr_src[k];
desc.dst_ptr_array = ptr_dst[k];
desc.ptr_array_len = (int)nelem[aproc[k]];
iproc = aproc[k];
gam_find_block_indices(handle, iproc, index);
index[0] = index[0]%GA[handle].nblock[0];
index[1] = index[1]%GA[handle].nblock[1];
gam_find_proc_from_sl_indices(handle,iproc,index);
if (p_handle >= 0) {
iproc = PGRP_LIST[p_handle].inv_map_proc_list[iproc];
}
rc = ARMCI_PutV(&desc, 1, (int)iproc);
if(rc) pnga_error("scatter failed in armci",rc);
}
} else if (GA[handle].distr_type == TILED ||
GA[handle].distr_type == TILED_IRREG) {
Integer index[MAXDIM];
for(k=0; k<naproc; k++) {
int rc;
desc.bytes = (int)item_size;
desc.src_ptr_array = ptr_src[k];
desc.dst_ptr_array = ptr_dst[k];
desc.ptr_array_len = (int)nelem[aproc[k]];
iproc = aproc[k];
gam_find_block_indices(handle, iproc, index);
index[0] = index[0]%GA[handle].nblock[0];
index[1] = index[1]%GA[handle].nblock[1];
gam_find_tile_proc_from_indices(handle,iproc,index);
if (p_handle >= 0) {
iproc = PGRP_LIST[p_handle].inv_map_proc_list[iproc];
}
rc = ARMCI_PutV(&desc, 1, (int)iproc);
if(rc) pnga_error("scatter failed in armci",rc);
}
}
free(buf2);
free(buf1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rcx, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
testq %r8, %r8
jle 0x6fb13
movq %r8, %r14
movq %rdi, %r13
movq %rsi, 0x168(%rsp)
leaq 0x6e0ef(%rip), %r15 # 0xdc8b8
movq (%r15), %rax
leaq 0x3e8(%rdi), %rbx
imulq $0x368, %rdi, %rcx # imm = 0x368
movq %rcx, 0x80(%rsp)
movslq 0xd4e44(%rcx,%rax), %rax
movq %rax, 0x170(%rsp)
cmpq $-0x3e8, %rdi # imm = 0xFC18
jl 0x6e80a
leaq 0x68966(%rip), %rax # 0xd7168
movslq (%rax), %rax
cmpq %rax, %rbx
jl 0x6e83b
leaq 0x4aac7(%rip), %rsi # 0xb92d8
leaq 0x4c015(%rip), %rdx # 0xba82d
movq %r14, %r12
leaq 0x180(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30a0
movq %r14, %rdi
movq %r12, %r14
movq %r13, %rsi
callq 0x18f07
movq (%r15), %rax
imulq $0x368, %rbx, %r12 # imm = 0x368
cmpl $0x0, 0x8(%rax,%r12)
jne 0x6e87e
leaq 0x4aa9d(%rip), %rsi # 0xb92f1
leaq 0x4bfd2(%rip), %rdx # 0xba82d
movq %r14, %rbx
leaq 0x180(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30a0
movq %r14, %rdi
movq %rbx, %r14
movq %r13, %rsi
callq 0x18f07
leaq 0x6e093(%rip), %rax # 0xdc918
incq 0x28(%rax)
movq (%r15), %rax
movslq 0x210(%rax,%r12), %rdx
addq %r12, %rax
testq %rdx, %rdx
movq %rdx, 0xb0(%rsp)
js 0x6e8b9
leaq 0x6e065(%rip), %rcx # 0xdc910
movq (%rcx), %rcx
leaq (%rdx,%rdx,4), %rdx
movslq 0x4(%rcx,%rdx,8), %rcx
jmp 0x6e8cf
movq 0x2a8(%rax), %rcx
testq %rcx, %rcx
jg 0x6e8cf
leaq 0x6e0cc(%rip), %rcx # 0xdc998
movq (%rcx), %rcx
cmpl $0x0, 0x224(%rax)
movq %rcx, 0x90(%rsp)
je 0x6e90b
movq 0x298(%rax), %rbp
movq %rbp, %rax
shlq $0x22, %rax
movq %r14, %rdi
shlq $0x20, %rdi
addq %rax, %rdi
sarq $0x1d, %rdi
callq 0x33b0
testq %rax, %rax
jne 0x6e94b
movq %rbp, %rax
jmp 0x6e939
movq %rcx, %rax
shlq $0x22, %rax
movq %r14, %rdi
shlq $0x20, %rdi
addq %rax, %rdi
sarq $0x1d, %rdi
movq %rcx, %rbx
callq 0x33b0
testq %rax, %rax
je 0x6e934
movq %rbx, %r9
xorl %ebp, %ebp
jmp 0x6e953
movq %rbx, %rax
xorl %ebp, %ebp
leaq (%rax,%rax,2), %rsi
leaq 0x46d50(%rip), %rdi # 0xb5694
callq 0x18f07
xorl %eax, %eax
movq 0x90(%rsp), %r9
leaq (%rax,%r14,8), %r10
movq (%r15), %rsi
movl 0x224(%rsi,%r12), %ecx
movq %rbp, %rdi
testl %ecx, %ecx
cmoveq %r9, %rdi
leaq (%r10,%rdi,8), %r8
je 0x6e98c
testq %rbp, %rbp
jle 0x6e9a5
xorl %ecx, %ecx
xorl %edx, %edx
movq %rcx, (%r10,%rdx,8)
movq %rcx, (%r8,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x6e97a
jmp 0x6e9a5
testq %r9, %r9
jle 0x6e9a5
xorl %ecx, %ecx
xorl %edx, %edx
movq %rcx, (%r10,%rdx,8)
movq %rcx, (%r8,%rdx,8)
incq %rdx
cmpq %rdx, %r9
jne 0x6e995
movq %r10, 0xb8(%rsp)
movq %r13, 0x48(%rsp)
leaq (%rdi,%rdi,2), %rcx
movq %rcx, 0x40(%rsp)
shlq $0x4, %rdi
movq %rdi, 0x18(%rsp)
cmpq $0x2, %r14
movl $0x1, %ebx
movq %r14, 0x118(%rsp)
cmovgeq %r14, %rbx
movq %r12, 0x10(%rsp)
cmpq $0x0, 0x2a8(%rsi,%r12)
movq %rax, 0x88(%rsp)
movq %r8, 0x68(%rsp)
leaq 0xf0(%rsp), %r14
leaq 0x180(%rsp), %r13
je 0x6eab9
xorl %r12d, %r12d
movq 0x78(%rsp), %rcx
movq (%rcx,%r12), %rcx
movq %rcx, 0xf0(%rsp)
movq 0x70(%rsp), %rcx
movq (%rcx,%r12), %rcx
movq %rcx, 0xf8(%rsp)
leaq (%rax,%r12), %r15
movq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5de9b
testq %rax, %rax
jne 0x6ea78
movq 0x78(%rsp), %rax
movq (%rax,%r12), %rdx
movq 0x70(%rsp), %rax
movq (%rax,%r12), %rcx
movq %r13, %rdi
leaq 0x4bc05(%rip), %rsi # 0xba669
xorl %eax, %eax
callq 0x30a0
movq %r13, %rdi
movq 0x48(%rsp), %rsi
callq 0x18f07
leaq 0x6de39(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x2c0(%rax,%rcx), %rax
movq (%r15), %rcx
movq (%rax,%rcx,8), %rax
movq 0x68(%rsp), %rcx
incq (%rcx,%rax,8)
addq $0x8, %r12
decq %rbx
movq 0x88(%rsp), %rax
jne 0x6ea0d
jmp 0x6eb48
xorl %r12d, %r12d
movq 0x78(%rsp), %rcx
movq (%rcx,%r12), %rcx
movq %rcx, 0xf0(%rsp)
movq 0x70(%rsp), %rcx
movq (%rcx,%r12), %rcx
movq %rcx, 0xf8(%rsp)
leaq (%rax,%r12), %r15
movq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5de9b
testq %rax, %rax
jne 0x6eb27
movq 0x78(%rsp), %rax
movq (%rax,%r12), %rdx
movq 0x70(%rsp), %rax
movq (%rax,%r12), %rcx
movq %r13, %rdi
leaq 0x4bb56(%rip), %rsi # 0xba669
xorl %eax, %eax
callq 0x30a0
movq %r13, %rdi
movq 0x48(%rsp), %rsi
callq 0x18f07
movq (%r15), %rax
movq 0x68(%rsp), %rcx
incq (%rcx,%rax,8)
addq $0x8, %r12
decq %rbx
movq 0x88(%rsp), %rax
jne 0x6eabc
movq 0x18(%rsp), %r13
movq 0xb8(%rsp), %rax
addq %rax, %r13
movq 0x40(%rsp), %rdx
leaq (%rax,%rdx,8), %rax
movq %rax, 0xc8(%rsp)
leaq 0x6dd48(%rip), %rbx # 0xdc8b8
movq (%rbx), %rax
movq 0x10(%rsp), %r14
cmpl $0x0, 0x224(%rax,%r14)
je 0x6ebb9
testq %rbp, %rbp
leaq 0x6dd8b(%rip), %rdi # 0xdc918
jle 0x6ebf7
xorl %eax, %eax
xorl %r15d, %r15d
movq 0xc8(%rsp), %rdx
cmpq $0x0, (%rcx,%rax,8)
jle 0x6ebaf
movq %rax, (%r13,%r15,8)
movq %r15, (%rdx,%rax,8)
incq %r15
incq %rax
cmpq %rax, %rbp
jne 0x6eb9c
jmp 0x6ebfa
movq 0x90(%rsp), %rdx
testq %rdx, %rdx
leaq 0x6dd4d(%rip), %rdi # 0xdc918
jle 0x6ebf7
xorl %eax, %eax
xorl %r15d, %r15d
movq 0xc8(%rsp), %rsi
cmpq $0x0, (%rcx,%rax,8)
jle 0x6ebed
movq %rax, (%r13,%r15,8)
movq %r15, (%rsi,%rax,8)
incq %r15
incq %rax
cmpq %rax, %rdx
jne 0x6ebda
jmp 0x6ebfa
xorl %r15d, %r15d
addq %r15, 0x70(%rdi)
movq %r15, %rbx
shlq $0x4, %rbx
movq 0x118(%rsp), %r12
shlq $0x4, %r12
leal (%rbx,%r12), %eax
leal (%r15,%r15,4), %ecx
leal (%rax,%rcx,8), %eax
leaq (,%r15,8), %rbp
addl %ebp, %eax
movslq %eax, %rdi
callq 0x33b0
testq %rax, %rax
movq %rax, 0x50(%rsp)
jne 0x6ec4c
leaq 0x46a55(%rip), %rdi # 0xb5694
movq %r15, %rsi
callq 0x18f07
movq 0x50(%rsp), %rax
addq %rax, %rbx
addq %rbx, %r12
movq %r12, 0x98(%rsp)
movq %rbp, 0x160(%rsp)
leaq (%r12,%rbp), %rax
movq %rax, 0x40(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0xa8(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, (%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0xa0(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0xc0(%rsp)
leaq 0x6dc1a(%rip), %rax # 0xdc8b8
movq (%rax), %rax
cmpl $0x0, 0x224(%rax,%r14)
movq %r13, 0x18(%rsp)
movq %r15, 0x8(%rsp)
movq %rbx, 0x158(%rsp)
je 0x6ed7f
testq %r15, %r15
movq (%rsp), %rbp
movq 0xc0(%rsp), %r15
jle 0x6f352
xorl %ebx, %ebx
movq 0x8(%rsp), %r12
movq 0x48(%rsp), %r14
movq 0x18(%rsp), %rax
movq (%rax,%rbx), %r13
movq %r14, %rdi
movq %r13, %rsi
leaq 0xe0(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x5f51f
movq 0xe0(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rax, (%rcx,%rbx)
movq 0xe8(%rsp), %rax
movq %rax, (%rbp,%rbx)
movq 0xd0(%rsp), %rax
movq 0xa8(%rsp), %rcx
movq %rax, (%rcx,%rbx)
movq 0xd8(%rsp), %rax
movq 0xa0(%rsp), %rcx
movq %rax, (%rcx,%rbx)
movq 0x98(%rsp), %rax
leaq (%rax,%rbx), %rdx
leaq (%r15,%rbx), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %r13
callq 0x6c674
addq $0x8, %rbx
decq %r12
jne 0x6ece3
jmp 0x6f352
testq %r15, %r15
jle 0x6f352
movq 0x80(%rsp), %rax
leaq 0xd50a8(%rax), %rcx
movq %rcx, 0x110(%rsp)
leaq 0xd5068(%rax), %rcx
movq %rcx, 0x178(%rsp)
addq $0xd4ee0, %rax # imm = 0xD4EE0
movq %rax, 0x108(%rsp)
xorl %r14d, %r14d
movq (%r13,%r14,8), %rsi
leaq 0x6daed(%rip), %rbx # 0xdc8b8
movq (%rbx), %rax
movq 0x10(%rsp), %r15
cmpq $0x0, 0x2a8(%rax,%r15)
jle 0x6edec
addq %r15, %rax
movq 0x2a0(%rax), %rax
movq (%rax,%rsi,8), %rsi
movq 0x48(%rsp), %rdi
leaq 0xe0(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x5f51f
movq 0xe0(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
movq 0xe8(%rsp), %rax
movq (%rsp), %r9
movq %rax, (%r9,%r14,8)
movq 0xd0(%rsp), %rax
movq 0xa8(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
movq 0xd8(%rsp), %rax
movq 0xa0(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
movq (%rbx), %rsi
leaq (%rsi,%r15), %rbx
movq 0xc0(%rsi,%r15), %rdx
movq 0xc8(%rsi,%r15), %rdi
movq 0x2a8(%rsi,%r15), %r12
movl 0x224(%rsi,%r15), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
movq %rdx, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
jae 0x6ef57
movswl (%rbx), %r8d
movq (%r13,%r14,8), %rcx
movslq %ecx, %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x180(%rsp)
movl %r8d, %edi
cmpl $0x2, %r8d
jl 0x6eef3
movl 0x180(%rsp), %edx
movq 0x110(%rsp), %rax
leaq (%rsi,%rax), %r9
leaq -0x1(%rdi), %r10
xorl %r11d, %r11d
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%r9,%r11,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%r9,%r11,8)
movl %edx, 0x184(%rsp,%r11,4)
incq %r11
cmpq %r11, %r10
jne 0x6eecb
testw %r8w, %r8w
jle 0x6f1ef
addq 0x178(%rsp), %rsi
shlq $0x2, %rdi
xorl %eax, %eax
movslq 0x180(%rsp,%rax), %rcx
movq (%rsi,%rax,2), %rdx
movq %rdx, %r8
imulq %rcx, %r8
incq %r8
movq %r8, 0x120(%rsp,%rax,2)
incq %rcx
imulq %rdx, %rcx
movq %rcx, 0x20(%rsp,%rax,2)
movq -0x1f8(%rsi,%rax,2), %rdx
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
movq %rcx, 0x20(%rsp,%rax,2)
addq $0x4, %rax
cmpq %rax, %rdi
jne 0x6ef0b
jmp 0x6f1ef
cmpl $0x4, %eax
je 0x6efb1
testl %eax, %eax
jne 0x6f1f3
testq %r12, %r12
je 0x6f08c
movq (%r13,%r14,8), %rax
movswq (%rbx), %r15
cmpq %r12, %rax
jge 0x6f1c1
testw %r15w, %r15w
jle 0x6f146
movq 0x108(%rsp), %rcx
leaq (%rsi,%rcx), %rdx
movl $0x1, %ecx
xorl %edi, %edi
movslq (%rdx,%rdi,4), %r8
imulq %r8, %rcx
incq %rdi
cmpq %rdi, %r15
jne 0x6ef9c
jmp 0x6f14b
movswl (%rbx), %r8d
movq (%r13,%r14,8), %rcx
movslq %ecx, %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x180(%rsp)
movl %r8d, %edi
cmpl $0x2, %r8d
jl 0x6f018
movl 0x180(%rsp), %edx
movq 0x110(%rsp), %rax
leaq (%rsi,%rax), %r9
leaq -0x1(%rdi), %r10
xorl %r11d, %r11d
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%r9,%r11,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%r9,%r11,8)
movl %edx, 0x184(%rsp,%r11,4)
incq %r11
cmpq %r11, %r10
jne 0x6eff0
testw %r8w, %r8w
jle 0x6f1ef
movq 0x1e8(%rsi,%r15), %rax
shlq $0x2, %rdi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x180(%rsp,%rcx), %r8
movslq %edx, %rsi
addq %r8, %rsi
movq (%rax,%rsi,8), %r9
movq %r9, 0x120(%rsp,%rcx,2)
movq 0x260(%rbx,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x6f06d
movq 0x1e8(%rbx), %r8
movq 0x8(%r8,%rsi,8), %rsi
decq %rsi
jmp 0x6f072
movq 0x30(%rbx,%rcx,2), %rsi
movq %rsi, 0x20(%rsp,%rcx,2)
addl 0x260(%rbx,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rdi
jne 0x6f032
jmp 0x6f1ef
movswq (%rbx), %r15
testq %r15, %r15
jle 0x6f0b9
movq 0x108(%rsp), %rax
addq %rsi, %rax
movl $0x1, %ecx
xorl %edx, %edx
movslq (%rax,%rdx,4), %rdi
imulq %rdi, %rcx
incq %rdx
cmpq %rdx, %r15
jne 0x6f0a7
jmp 0x6f0be
movl $0x1, %ecx
movq (%r13,%r14,8), %rax
cmpq %rcx, %rax
setge %cl
testq %rax, %rax
sets %dl
orb %cl, %dl
jne 0x6f1c1
testw %r15w, %r15w
jle 0x6f1f3
movq 0x1e8(%rbx), %rcx
addq 0x80(%rsp), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%rdi,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%r8,8), %r11
movq %r11, 0x120(%rsp,%rdi,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x6f125
movq 0xd4e70(%rsi,%rdi,8), %rdx
jmp 0x6f12d
movq 0x8(%r10,%r8,8), %rdx
decq %rdx
addq %r9, %r8
movq %rdx, 0x20(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %r15
movq (%rsp), %r9
jne 0x6f0f5
jmp 0x6f1f3
movl $0x1, %ecx
testq %rax, %rax
js 0x6f1c1
cmpq %rcx, %rax
jge 0x6f1c1
testw %r15w, %r15w
jle 0x6f1f3
movq 0x1e8(%rbx), %rcx
addq 0x80(%rsp), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x120(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x6f1a3
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x6f1ab
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
addq %r9, %rdi
movq %rdx, 0x20(%rsp,%r8,8)
incq %r8
cmpq %r8, %r15
movq (%rsp), %r9
jne 0x6f173
jmp 0x6f1f3
testw %r15w, %r15w
jle 0x6f1f3
shlq $0x3, %r15
leaq 0x120(%rsp), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3170
leaq 0x20(%rsp), %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x3170
movq (%rsp), %r9
cmpl $0x0, 0x210(%rbx)
je 0x6f218
movq (%r13,%r14,8), %rbp
testq %r12, %r12
movq 0x40(%rsp), %rdx
je 0x6f234
movq 0x2a0(%rbx), %rax
movq (%rax,%rbp,8), %rbp
jmp 0x6f234
leaq 0x6d6f1(%rip), %rax # 0xdc910
movq (%rax), %rax
movq 0x18(%rax), %rax
movq (%r13,%r14,8), %rcx
movslq (%rax,%rcx,4), %rbp
movq 0x40(%rsp), %rdx
movq 0x120(%rsp), %rbx
movq 0x128(%rsp), %r12
movq 0x20(%rsp), %r13
movq 0x28(%rsp), %r10
movq (%rdx,%r14,8), %r8
cmpq %rbx, %r8
setl %al
cmpq %r13, %r8
setg %cl
orb %al, %cl
jne 0x6f278
movq (%r9,%r14,8), %rax
cmpq %r12, %rax
setl %cl
cmpq %r10, %rax
setg %al
orb %cl, %al
cmpb $0x1, %al
jne 0x6f2c6
movq 0x18(%rsp), %rax
movq (%rax,%r14,8), %rcx
movq (%r9,%r14,8), %r9
leaq 0x180(%rsp), %r15
movq %r15, %rdi
leaq 0x4b341(%rip), %rsi # 0xba5d8
leaq 0x4b36c(%rip), %rdx # 0xba60a
xorl %eax, %eax
pushq %r10
pushq %r12
pushq %r13
pushq %rbx
callq 0x30a0
addq $0x20, %rsp
movq %r15, %rdi
movq 0x48(%rsp), %rsi
callq 0x18f07
movq (%rsp), %r9
movq 0x40(%rsp), %rdx
movq 0x60(%rsp), %r8
leaq 0x1(,%r8,2), %rax
subq %rbx, %rax
addq %r13, %rax
movq 0x58(%rsp), %rcx
subq %r12, %rcx
addq (%r9,%r14,8), %rcx
imulq %rax, %rcx
subq %rbx, %r8
addq (%rdx,%r14,8), %r8
addq %rcx, %r8
leaq 0x6d5be(%rip), %rcx # 0xdc8b8
movq (%rcx), %rcx
movq 0x10(%rsp), %rsi
movslq 0x4(%rcx,%rsi), %rdx
shlq $0x4, %rdx
leaq 0x67e6e(%rip), %rdi # 0xd7180
imulq -0x3e78(%rdx,%rdi), %r8
movq 0x1e0(%rcx,%rsi), %rcx
addq (%rcx,%rbp,8), %r8
movq 0x98(%rsp), %rcx
movq %r8, (%rcx,%r14,8)
movq 0xc0(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq 0x8(%rsp), %r14
movq 0x18(%rsp), %r13
jne 0x6edbf
movq 0x170(%rsp), %rcx
shlq $0x4, %rcx
leaq 0x67e1b(%rip), %rax # 0xd7180
movq -0x3e78(%rcx,%rax), %rcx
movq %rcx, 0x60(%rsp)
cvtsi2sd %rcx, %xmm0
movq 0x118(%rsp), %r14
cvtsi2sd %r14, %xmm1
leaq 0x6d61d(%rip), %rax # 0xdc9a8
movq (%rax), %rax
movq 0x88(%rsp), %r10
movq (%r10,%rax,8), %rax
movq 0x68(%rsp), %r9
cvtsi2sdq (%r9,%rax,8), %xmm2
unpcklpd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
leaq 0x6d4a8(%rip), %rax # 0xdc858
movupd 0x50(%rax), %xmm2
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, 0x50(%rax)
movq 0x50(%rsp), %rdi
movq 0x158(%rsp), %rax
movq %rax, (%rdi)
leaq (%rax,%r14,8), %rax
movq 0x8(%rsp), %rdx
movq %rax, (%rdi,%rdx,8)
cmpq $0x2, %rdx
movq 0x160(%rsp), %rbx
jl 0x6f428
movq (%rdi), %rax
movq (%rdi,%rdx,8), %rcx
decq %rdx
leaq (%rbx,%rdi), %rsi
addq $0x8, %rsi
xorl %r11d, %r11d
movq (%r13,%r11,8), %r8
movq (%r9,%r8,8), %r8
leaq (%rax,%r8,8), %rax
movq %rax, 0x8(%rdi,%r11,8)
leaq (%rcx,%r8,8), %rcx
movq %rcx, (%rsi,%r11,8)
incq %r11
cmpq %r11, %rdx
jne 0x6f406
movq %rdi, %rax
addq %rbx, %rax
movq %rax, 0x58(%rsp)
cmpq $0x2, %r14
movl $0x1, %ebx
cmovgeq %r14, %rbx
leaq 0x180(%rsp), %r14
xorl %r12d, %r12d
leaq 0x6d466(%rip), %rcx # 0xdc8b8
movq 0x10(%rsp), %rdx
movq 0xb8(%rsp), %rsi
movq 0x98(%rsp), %r8
movq 0x40(%rsp), %r9
movq 0x168(%rsp), %rbp
movq (%rsp), %r11
movq (%r10,%r12,8), %rax
movq (%rcx), %rcx
cmpq $0x0, 0x2a8(%rcx,%rdx)
jle 0x6f498
addq %rdx, %rcx
movq 0x2c0(%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq (%rsi,%rax,8), %r15
leaq 0x1(%r15), %rcx
movq %rcx, (%rsi,%rax,8)
movq 0xc8(%rsp), %rcx
movq (%rcx,%rax,8), %r13
movq (%rdi,%r13,8), %rax
movq %rbp, (%rax,%r15,8)
movq 0x78(%rsp), %rax
movq (%rax,%r12,8), %rcx
movq (%r9,%r13,8), %r9
cmpq %r9, %rcx
jl 0x6f4f5
movq 0xa8(%rsp), %rax
cmpq (%rax,%r13,8), %rcx
jg 0x6f4f5
movq 0x70(%rsp), %rax
movq (%rax,%r12,8), %rax
cmpq (%r11,%r13,8), %rax
jl 0x6f4f5
movq 0xa0(%rsp), %rdx
cmpq (%rdx,%r13,8), %rax
jle 0x6f564
movq 0x70(%rsp), %rax
movq (%rax,%r12,8), %r8
subq $0x8, %rsp
movq %r14, %rdi
leaq 0x4b173(%rip), %rsi # 0xba67f
movl %r13d, %edx
xorl %eax, %eax
movq 0xa8(%rsp), %r10
pushq (%r10,%r13,8)
pushq (%r11,%r13,8)
movq 0xc0(%rsp), %r10
pushq (%r10,%r13,8)
callq 0x30a0
addq $0x20, %rsp
movq %r14, %rdi
movq 0x48(%rsp), %rsi
callq 0x18f07
movq (%rsp), %r11
movq 0x98(%rsp), %r8
movq 0xb8(%rsp), %rsi
movq 0x50(%rsp), %rdi
movq 0x88(%rsp), %r10
movq 0x70(%rsp), %rax
movq (%rax,%r12,8), %rax
subq (%r11,%r13,8), %rax
movq 0xc0(%rsp), %rcx
imulq (%rcx,%r13,8), %rax
movq 0x78(%rsp), %rcx
addq (%rcx,%r12,8), %rax
movq 0x40(%rsp), %r9
subq (%r9,%r13,8), %rax
movq 0x60(%rsp), %rdx
imulq %rdx, %rax
addq (%r8,%r13,8), %rax
movq 0x58(%rsp), %rcx
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx,%r15,8)
incq %r12
addq %rdx, %rbp
cmpq %r12, %rbx
leaq 0x6d2fe(%rip), %rcx # 0xdc8b8
movq 0x10(%rsp), %rdx
jne 0x6f478
movq (%rcx), %rax
movl 0x224(%rax,%rdx), %eax
cmpq $0x4, %rax
movq 0xb0(%rsp), %rbp
ja 0x6fb01
leaq 0x4ac98(%rip), %rcx # 0xba280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x8(%rsp)
jle 0x6fb01
movq 0x80(%rsp), %r13
leaq 0xd50a8(%r13), %r15
addq $0xd4ee0, %r13 # imm = 0xD4EE0
xorl %r12d, %r12d
leaq 0x20(%rsp), %rbx
leaq 0x4b08e(%rip), %r14 # 0xba6b0
movq 0x60(%rsp), %rax
movl %eax, 0x34(%rsp)
movq (%rdi,%r12,8), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax,%r12,8), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r12,8), %rsi
movq 0x68(%rsp), %rax
movl (%rax,%rsi,8), %eax
movl %eax, 0x30(%rsp)
leaq 0x6d25a(%rip), %rax # 0xdc8b8
movq (%rax), %rdi
movq 0x10(%rsp), %rcx
movswl (%rdi,%rcx), %r8d
movslq %esi, %rax
cqto
idivq 0x260(%rdi,%rcx)
movq %rdx, %rcx
movq %rdx, 0x180(%rsp)
movl %r8d, %r9d
cmpl $0x2, %r8d
jl 0x6f6c2
leaq (%rdi,%r15), %r10
leaq -0x1(%r9), %r11
xorl %ebp, %ebp
movq %rcx, %rdx
movslq %esi, %rax
subq %rdx, %rax
cqto
idivq -0x8(%r10,%rbp,8)
movq %rax, %rsi
movslq %esi, %rax
cqto
idivq (%r10,%rbp,8)
movq %rdx, 0x188(%rsp,%rbp,8)
incq %rbp
cmpq %rbp, %r11
jne 0x6f699
movslq %r8d, %rsi
movq 0x10(%rsp), %r11
movslq 0xa0(%rdi,%r11), %r10
movq %rcx, %rax
cqto
idivq %r10
movq %rdx, 0x180(%rsp)
movq 0x188(%rsp), %rax
movslq 0xa4(%rdi,%r11), %rcx
cqto
idivq %rcx
movq %rdx, 0x188(%rsp)
testw %si, %si
jle 0x6f72c
leaq (%rdi,%r13), %rcx
xorl %r10d, %r10d
movq 0x180(%rsp,%r10,8), %rax
movslq (%rcx,%r10,4), %r11
cqto
idivq %r11
movq %rdx, 0x120(%rsp,%r10,8)
incq %r10
cmpq %r10, %r9
jne 0x6f70b
movq 0x118(%rsp,%rsi,8), %rax
cmpw $0x2, %r8w
movq 0xb0(%rsp), %rsi
jl 0x6f76b
addl $-0x2, %r8d
addq %r13, %rdi
movslq (%rdi,%r8,4), %rdx
imulq %rax, %rdx
addq 0x120(%rsp,%r8,8), %rdx
leaq -0x1(%r8), %rcx
movq %rdx, %rax
testq %r8, %r8
movq %rcx, %r8
jg 0x6f74a
jmp 0x6f76e
movq %rax, %rdx
testl %esi, %esi
js 0x6f788
leaq 0x6d197(%rip), %rax # 0xdc910
movq (%rax), %rax
leaq (%rsi,%rsi,4), %rcx
movq 0x18(%rax,%rcx,8), %rax
movl (%rax,%rdx,4), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59037
testl %eax, %eax
je 0x6f7a4
movslq %eax, %rsi
movq %r14, %rdi
callq 0x18f07
incq %r12
cmpq 0x8(%rsp), %r12
movq 0x50(%rsp), %rdi
jne 0x6f622
jmp 0x6fb01
cmpq $0x0, 0x8(%rsp)
jle 0x6fb01
movq 0x80(%rsp), %r13
leaq 0xd50a8(%r13), %r15
addq $0xd4ee0, %r13 # imm = 0xD4EE0
xorl %r12d, %r12d
leaq 0x20(%rsp), %rbx
leaq 0x4aec3(%rip), %r14 # 0xba6b0
movq 0x60(%rsp), %rax
movl %eax, 0x34(%rsp)
movq (%rdi,%r12,8), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax,%r12,8), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r12,8), %rsi
movq 0x68(%rsp), %rax
movl (%rax,%rsi,8), %eax
movl %eax, 0x30(%rsp)
leaq 0x6d08f(%rip), %rax # 0xdc8b8
movq (%rax), %rdi
movq 0x10(%rsp), %rcx
movswl (%rdi,%rcx), %r8d
movslq %esi, %rax
cqto
idivq 0x260(%rdi,%rcx)
movq %rdx, %rcx
movq %rdx, 0x180(%rsp)
movl %r8d, %r9d
cmpl $0x2, %r8d
jl 0x6f88d
leaq (%rdi,%r15), %r10
leaq -0x1(%r9), %r11
xorl %ebp, %ebp
movq %rcx, %rdx
movslq %esi, %rax
subq %rdx, %rax
cqto
idivq -0x8(%r10,%rbp,8)
movq %rax, %rsi
movslq %esi, %rax
cqto
idivq (%r10,%rbp,8)
movq %rdx, 0x188(%rsp,%rbp,8)
incq %rbp
cmpq %rbp, %r11
jne 0x6f864
movslq %r8d, %rsi
movq 0x10(%rsp), %r11
movslq 0xa0(%rdi,%r11), %r10
movq %rcx, %rax
cqto
idivq %r10
movq %rdx, 0x180(%rsp)
movq 0x188(%rsp), %rax
movslq 0xa4(%rdi,%r11), %rcx
cqto
idivq %rcx
movq %rdx, 0x188(%rsp)
testw %si, %si
jle 0x6f8f7
leaq (%rdi,%r13), %rcx
xorl %r10d, %r10d
movq 0x180(%rsp,%r10,8), %rax
movslq (%rcx,%r10,4), %r11
cqto
idivq %r11
movq %rdx, 0x120(%rsp,%r10,8)
incq %r10
cmpq %r10, %r9
jne 0x6f8d6
movq 0x118(%rsp,%rsi,8), %rax
cmpw $0x2, %r8w
movq 0xb0(%rsp), %rsi
jl 0x6f936
addl $-0x2, %r8d
addq %r13, %rdi
movslq (%rdi,%r8,4), %rdx
imulq %rax, %rdx
addq 0x120(%rsp,%r8,8), %rdx
leaq -0x1(%r8), %rcx
movq %rdx, %rax
testq %r8, %r8
movq %rcx, %r8
jg 0x6f915
jmp 0x6f939
movq %rax, %rdx
testl %esi, %esi
js 0x6f953
leaq 0x6cfcc(%rip), %rax # 0xdc910
movq (%rax), %rax
leaq (%rsi,%rsi,4), %rcx
movq 0x18(%rax,%rcx,8), %rax
movl (%rax,%rdx,4), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59037
testl %eax, %eax
je 0x6f96f
movslq %eax, %rsi
movq %r14, %rdi
callq 0x18f07
incq %r12
cmpq 0x8(%rsp), %r12
movq 0x50(%rsp), %rdi
jne 0x6f7ed
jmp 0x6fb01
cmpq $0x0, 0x8(%rsp)
jle 0x6fb01
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbx
leaq 0x4ad0e(%rip), %r14 # 0xba6b0
leaq 0x6cf67(%rip), %r12 # 0xdc910
leaq (,%rbp,4), %r13
addq %rbp, %r13
movq 0x60(%rsp), %rax
movl %eax, 0x34(%rsp)
movq (%rdi,%r15,8), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax,%r15,8), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r15,8), %rdx
movq 0x68(%rsp), %rax
movl (%rax,%rdx,8), %eax
movl %eax, 0x30(%rsp)
testl %ebp, %ebp
js 0x6f9fb
movq (%r12), %rax
movq 0x18(%rax,%r13,8), %rax
movl (%rax,%rdx,4), %edx
jmp 0x6fa23
leaq 0x6ceb6(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq 0x10(%rsp), %rcx
cmpq $0x0, 0x2a8(%rax,%rcx)
jle 0x6fa23
addq %rcx, %rax
movq 0x2a0(%rax), %rax
movq (%rax,%rdx,8), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59037
testl %eax, %eax
je 0x6fa3f
movslq %eax, %rsi
movq %r14, %rdi
callq 0x18f07
incq %r15
cmpq %r15, 0x8(%rsp)
movq 0x50(%rsp), %rdi
jne 0x6f9b4
jmp 0x6fb01
cmpq $0x0, 0x8(%rsp)
jle 0x6fb01
xorl %r15d, %r15d
leaq 0x6cea3(%rip), %r12 # 0xdc910
leaq (,%rbp,4), %r13
addq %rbp, %r13
leaq 0x20(%rsp), %rbx
leaq 0x4ac2c(%rip), %r14 # 0xba6b0
movq 0x60(%rsp), %rax
movl %eax, 0x34(%rsp)
movq (%rdi,%r15,8), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax,%r15,8), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r15,8), %rcx
movq %rcx, %rax
cqto
idivq 0x90(%rsp)
movq 0x68(%rsp), %rax
movl (%rax,%rcx,8), %eax
movl %eax, 0x30(%rsp)
testl %ebp, %ebp
js 0x6fad6
movq (%r12), %rax
movq 0x18(%rax,%r13,8), %rax
movl (%rax,%rdx,4), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x59037
testl %eax, %eax
je 0x6faf2
movslq %eax, %rsi
movq %r14, %rdi
callq 0x18f07
incq %r15
cmpq %r15, 0x8(%rsp)
movq 0x50(%rsp), %rdi
jne 0x6fa84
callq 0x3330
movq 0x88(%rsp), %rdi
callq 0x3330
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/onesided.c |
pnga_alloc_gatscat_buf | void pnga_alloc_gatscat_buf(Integer nelems)
{
Integer nprocs = pnga_nnodes();
if (GA_prealloc_gatscat)
pnga_error("Gather/scatter buffers already allocated",nelems);
GA_prealloc_gatscat = nelems;
GA_header =(Integer *)pnga_malloc(nprocs, MT_F_INT, "ga_gat_header");
GA_list =(Integer *)pnga_malloc(nelems, MT_F_INT, "ga_gat_list");
GA_elems =(Integer *)pnga_malloc(nprocs, MT_F_INT, "ga_gat_nelems");
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %eax, %eax
callq 0x68602
movq %rax, %rbx
cmpl $0x0, 0x6ae31(%rip) # 0xdea20
je 0x73c00
leaq 0x46b59(%rip), %rdi # 0xba751
movq %r14, %rsi
callq 0x18f07
movl %r14d, 0x6ae19(%rip) # 0xdea20
leaq 0x46b6c(%rip), %rdx # 0xba77a
movq %rbx, %rdi
movl $0x3f2, %esi # imm = 0x3F2
callq 0x5d36c
movq %rax, 0x6ae06(%rip) # 0xdea28
leaq 0x46b5f(%rip), %rdx # 0xba788
movq %r14, %rdi
movl $0x3f2, %esi # imm = 0x3F2
callq 0x5d36c
movq %rax, 0x6adf3(%rip) # 0xdea30
leaq 0x46b50(%rip), %rdx # 0xba794
movq %rbx, %rdi
movl $0x3f2, %esi # imm = 0x3F2
callq 0x5d36c
movq %rax, 0x6ade0(%rip) # 0xdea38
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /GlobalArrays[P]ga/global/src/onesided.c |
pnga_gather2d | void pnga_gather2d(Integer g_a, void *v, Integer *i, Integer *j,
Integer nv)
{
Integer k, kk, proc, item_size;
Integer *aproc, naproc; /* active processes and numbers */
Integer *map; /* map the active processes to allocated space */
char *buf1, *buf2;
Integer handle = g_a + GA_OFFSET;
Integer nproc, p_handle, iproc;
Integer *count; /* counters for each process */
Integer *nelem; /* number of elements for each process */
/* source and destination pointers for each process */
void ***ptr_src, ***ptr_dst;
void **ptr_org; /* the entire pointer array */
armci_giov_t desc;
Integer *ilo, *ihi, *jlo, *jhi, *ldp, *owner;
Integer lo[2], hi[2];
char **ptr_ref;
Integer num_blocks=0;
Integer subscrpt[2];
if (nv < 1) return;
ga_check_handleM(g_a, "ga_gather");
GAstat.numgat++;
/* determine how many processors are associated with array */
p_handle = GA[handle].p_handle;
if (p_handle < 0) {
nproc = GAnproc;
if (GA[handle].num_rstrctd > 0) {
nproc = GA[handle].num_rstrctd;
}
} else {
nproc = PGRP_LIST[p_handle].map_nproc;
}
/* allocate temp memory */
if (GA[handle].distr_type == REGULAR) {
buf1 = malloc((int)(nproc *4 + nv)* (sizeof(Integer)));
if(buf1 == NULL) pnga_error("malloc failed", 3*nproc);
} else {
num_blocks = GA[handle].block_total;
buf1 = malloc((int)(num_blocks *4 + nv)* (sizeof(Integer)));
if(buf1 == NULL) pnga_error("malloc failed", 3*num_blocks);
}
owner = (Integer *)buf1;
count = owner+ nv;
if (GA[handle].distr_type == REGULAR) {
nelem = count + nproc;
aproc = count + 2 * nproc;
map = count + 3 * nproc;
} else {
nelem = count + num_blocks;
aproc = count + 2 * num_blocks;
map = count + 3 * num_blocks;
}
if (GA[handle].distr_type == REGULAR) {
/* initialize the counters and nelem */
for(kk=0; kk<nproc; kk++) {
count[kk] = 0; nelem[kk] = 0;
}
} else {
for(kk=0; kk<num_blocks; kk++) {
count[kk] = 0; nelem[kk] = 0;
}
}
/* find proc or block that owns the (i,j) element; store it in temp: */
if (GA[handle].num_rstrctd == 0) {
for(k=0; k< nv; k++) {
subscrpt[0] = *(i+k);
subscrpt[1] = *(j+k);
if(! pnga_locate(g_a, subscrpt, owner+k)){
char err_string[ERR_STR_LEN];
sprintf(err_string,"invalid i/j=(%ld,%ld)", (long)i[k], (long)j[k]);
pnga_error(err_string, g_a);
}
iproc = owner[k];
nelem[iproc]++;
}
} else {
for(k=0; k< nv; k++) {
subscrpt[0] = *(i+k);
subscrpt[1] = *(j+k);
if(! pnga_locate(g_a, subscrpt, owner+k)){
char err_string[ERR_STR_LEN];
sprintf(err_string,"invalid i/j=(%ld,%ld)", (long)i[k], (long)j[k]);
pnga_error(err_string, g_a);
}
iproc = GA[handle].rank_rstrctd[owner[k]];
nelem[iproc]++;
}
}
naproc = 0;
if (GA[handle].distr_type == REGULAR) {
for(k=0; k<nproc; k++) if(nelem[k] > 0) {
aproc[naproc] = k;
map[k] = naproc;
naproc ++;
}
} else {
for(k=0; k<num_blocks; k++) if(nelem[k] > 0) {
aproc[naproc] = k;
map[k] = naproc;
naproc ++;
}
}
GAstat.numgat_procs += naproc;
buf2 = malloc((int)(2*naproc*sizeof(void **) + 2*nv*sizeof(void *) +
5*naproc*sizeof(Integer) + naproc*sizeof(char*)));
if(buf2 == NULL) pnga_error("malloc failed", naproc);
ptr_src = (void ***)buf2;
ptr_dst = (void ***)(buf2 + naproc*sizeof(void **));
ptr_org = (void **)(buf2 + 2*naproc*sizeof(void **));
ptr_ref = (char **)(buf2+2*naproc*sizeof(void **)+2*nv*sizeof(void *));
ilo = (Integer *)(((char*)ptr_ref) + naproc*sizeof(char*));
ihi = ilo + naproc;
jlo = ihi + naproc;
jhi = jlo + naproc;
ldp = jhi + naproc;
if (GA[handle].distr_type == REGULAR) {
for(kk=0; kk<naproc; kk++) {
iproc = aproc[kk];
if (GA[handle].num_rstrctd > 0)
iproc = GA[handle].rstrctd_list[iproc];
pnga_distribution(g_a, iproc, lo, hi);
ilo[kk] = lo[0];
jlo[kk] = lo[1];
ihi[kk] = hi[0];
jhi[kk] = hi[1];
/* get address of the first element owned by proc */
gaShmemLocation(aproc[kk], g_a, ilo[kk], jlo[kk], &(ptr_ref[kk]),
&(ldp[kk]));
}
} else {
for(kk=0; kk<naproc; kk++) {
iproc = aproc[kk];
pnga_distribution(g_a, iproc, lo, hi);
ilo[kk] = lo[0];
jlo[kk] = lo[1];
ihi[kk] = hi[0];
jhi[kk] = hi[1];
/* get address of the first element owned by proc */
pnga_access_block_ptr(g_a, iproc, &(ptr_ref[kk]), &(ldp[kk]));
pnga_release_block(g_a, iproc);
}
}
item_size = GA[GA_OFFSET + g_a].elemsize;
GAbytes.gattot += (double)item_size*nv;
/*This stuff is probably completely wrong. Doesn't affect performance,
* just statistics. */
iproc = owner[GAme];
GAbytes.gatloc += (double)item_size * nelem[iproc];
ptr_src[0] = ptr_org; ptr_dst[0] = ptr_org + nv;
for(k=1; k<naproc; k++) {
ptr_src[k] = ptr_src[k-1] + nelem[aproc[k-1]];
ptr_dst[k] = ptr_dst[k-1] + nelem[aproc[k-1]];
}
for(k=0; k<nv; k++){
Integer this_count;
proc = owner[k];
if (GA[handle].num_rstrctd > 0)
proc = GA[handle].rank_rstrctd[owner[k]];
this_count = count[proc];
count[proc]++;
proc = map[proc];
ptr_dst[proc][this_count] = ((char*)v) + k * item_size;
if(i[k] < ilo[proc] || i[k] > ihi[proc] ||
j[k] < jlo[proc] || j[k] > jhi[proc]){
char err_string[ERR_STR_LEN];
sprintf(err_string,"proc=%d invalid i/j=(%ld,%ld)><[%ld:%ld,%ld:%ld]",
(int)proc,(long)i[k],(long)j[k],
(long)ilo[proc],(long)ihi[proc],
(long)jlo[proc], (long)jhi[proc]);
pnga_error(err_string, g_a);
}
ptr_src[proc][this_count] = ptr_ref[proc] + item_size *
((j[k] - jlo[proc])* ldp[proc] + i[k] - ilo[proc]);
}
/* source and destination pointers are ready for all processes */
if (GA[handle].distr_type == REGULAR) {
for(k=0; k<naproc; k++) {
int rc;
desc.bytes = (int)item_size;
desc.src_ptr_array = ptr_src[k];
desc.dst_ptr_array = ptr_dst[k];
desc.ptr_array_len = (int)nelem[aproc[k]];
if (p_handle < 0) {
iproc = aproc[k];
if (GA[handle].num_rstrctd > 0)
iproc = GA[handle].rstrctd_list[iproc];
} else {
iproc = PGRP_LIST[p_handle].inv_map_proc_list[aproc[k]];
}
rc=ARMCI_GetV(&desc, 1, (int)iproc);
if(rc) pnga_error("gather failed in armci",rc);
}
} else if (GA[handle].distr_type == BLOCK_CYCLIC) {
for(k=0; k<naproc; k++) {
int rc;
desc.bytes = (int)item_size;
desc.src_ptr_array = ptr_src[k];
desc.dst_ptr_array = ptr_dst[k];
desc.ptr_array_len = (int)nelem[aproc[k]];
iproc = aproc[k];
iproc = iproc%nproc;
if (p_handle >= 0) {
iproc = PGRP_LIST[p_handle].inv_map_proc_list[iproc];
}
rc=ARMCI_GetV(&desc, 1, (int)iproc);
if(rc) pnga_error("gather failed in armci",rc);
}
} else if (GA[handle].distr_type == SCALAPACK) {
Integer index[MAXDIM];
for(k=0; k<naproc; k++) {
int rc;
desc.bytes = (int)item_size;
desc.src_ptr_array = ptr_src[k];
desc.dst_ptr_array = ptr_dst[k];
desc.ptr_array_len = (int)nelem[aproc[k]];
iproc = aproc[k];
gam_find_block_indices(handle, iproc, index);
index[0] = index[0]%GA[handle].nblock[0];
index[1] = index[1]%GA[handle].nblock[1];
gam_find_proc_from_sl_indices(handle,iproc,index);
if (p_handle >= 0) {
iproc = PGRP_LIST[p_handle].inv_map_proc_list[iproc];
}
rc=ARMCI_GetV(&desc, 1, (int)iproc);
if(rc) pnga_error("gather failed in armci",rc);
}
} else if (GA[handle].distr_type == TILED ||
GA[handle].distr_type == TILED_IRREG) {
Integer index[MAXDIM];
for(k=0; k<naproc; k++) {
int rc;
desc.bytes = (int)item_size;
desc.src_ptr_array = ptr_src[k];
desc.dst_ptr_array = ptr_dst[k];
desc.ptr_array_len = (int)nelem[aproc[k]];
iproc = aproc[k];
gam_find_block_indices(handle, iproc, index);
index[0] = index[0]%GA[handle].nblock[0];
index[1] = index[1]%GA[handle].nblock[1];
gam_find_tile_proc_from_indices(handle,iproc,index);
if (p_handle >= 0) {
iproc = PGRP_LIST[p_handle].inv_map_proc_list[iproc];
}
rc=ARMCI_GetV(&desc, 1, (int)iproc);
if(rc) pnga_error("gather failed in armci",rc);
}
}
free(buf2);
free(buf1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %rcx, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
testq %r8, %r8
jle 0x763d3
movq %r8, %rbp
movq %rdi, %r12
movq %rsi, 0x170(%rsp)
leaq 0x3e8(%rdi), %rbx
cmpq $-0x3e8, %rdi # imm = 0xFC18
jl 0x750c6
leaq 0x620aa(%rip), %rax # 0xd7168
movslq (%rax), %rax
cmpq %rax, %rbx
jl 0x750f1
leaq 0x4420b(%rip), %rsi # 0xb92d8
leaq 0x4574e(%rip), %rdx # 0xba822
leaq 0x180(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x18f07
leaq 0x677c0(%rip), %r15 # 0xdc8b8
movq (%r15), %rax
imulq $0x368, %rbx, %rbx # imm = 0x368
cmpl $0x0, 0x8(%rax,%rbx)
jne 0x75134
leaq 0x441e1(%rip), %rsi # 0xb92f1
leaq 0x4570b(%rip), %rdx # 0xba822
leaq 0x180(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x30a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x18f07
leaq 0x677dd(%rip), %rax # 0xdc918
incq 0x30(%rax)
movq (%r15), %rax
movslq 0x210(%rax,%rbx), %rsi
addq %rbx, %rax
testq %rsi, %rsi
js 0x75167
leaq 0x677b7(%rip), %rcx # 0xdc910
movq (%rcx), %rcx
leaq (%rsi,%rsi,4), %rdx
movslq 0x4(%rcx,%rdx,8), %r14
jmp 0x7517d
movq 0x2a8(%rax), %r14
testq %r14, %r14
jg 0x7517d
leaq 0x6781e(%rip), %rcx # 0xdc998
movq (%rcx), %r14
movq %rsi, 0x50(%rsp)
cmpl $0x0, 0x224(%rax)
je 0x751b6
movq 0x298(%rax), %r13
movq %r13, %rax
shlq $0x22, %rax
movq %rbp, %rdi
shlq $0x20, %rdi
addq %rax, %rdi
sarq $0x1d, %rdi
callq 0x33b0
testq %rax, %rax
jne 0x751d8
movq %r13, %rax
jmp 0x751e0
movq %r14, %rax
shlq $0x22, %rax
movq %rbp, %rdi
shlq $0x20, %rdi
addq %rax, %rdi
sarq $0x1d, %rdi
callq 0x33b0
xorl %r13d, %r13d
testq %rax, %rax
je 0x751dd
movq %rax, %rsi
jmp 0x751f2
movq %r14, %rax
leaq (%rax,%rax,2), %rsi
leaq 0x404a9(%rip), %rdi # 0xb5694
callq 0x18f07
xorl %esi, %esi
leaq (%rsi,%rbp,8), %r9
leaq 0x676bb(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movl 0x224(%rax,%rbx), %ecx
movq %r13, %rdi
testl %ecx, %ecx
cmoveq %r14, %rdi
leaq (%r9,%rdi,8), %r8
movq %r12, 0x10(%rsp)
je 0x75236
testq %r13, %r13
jle 0x7524f
xorl %ecx, %ecx
xorl %edx, %edx
movq %rcx, (%r9,%rdx,8)
movq %rcx, (%r8,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x75224
jmp 0x7524f
testq %r14, %r14
jle 0x7524f
xorl %ecx, %ecx
xorl %edx, %edx
movq %rcx, (%r9,%rdx,8)
movq %rcx, (%r8,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0x7523f
movq %r9, 0xc0(%rsp)
movq %r14, 0x118(%rsp)
leaq (%rdi,%rdi,2), %rcx
movq %rcx, 0x48(%rsp)
shlq $0x4, %rdi
movq %rdi, 0x18(%rsp)
cmpq $0x2, %rbp
movl $0x1, %r12d
movq %rbp, 0xb0(%rsp)
cmovgeq %rbp, %r12
movq %rbx, (%rsp)
cmpq $0x0, 0x2a8(%rax,%rbx)
movq %rsi, 0x88(%rsp)
movq %r8, 0x60(%rsp)
leaq 0xd0(%rsp), %r14
leaq 0x180(%rsp), %rbp
je 0x75364
xorl %ebx, %ebx
movq 0x78(%rsp), %rax
movq (%rax,%rbx), %rax
movq %rax, 0xd0(%rsp)
movq 0x70(%rsp), %rax
movq (%rax,%rbx), %rax
movq %rax, 0xd8(%rsp)
leaq (%rsi,%rbx), %r15
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5de9b
testq %rax, %rax
jne 0x75324
movq 0x78(%rsp), %rax
movq (%rax,%rbx), %rdx
movq 0x70(%rsp), %rax
movq (%rax,%rbx), %rcx
movq %rbp, %rdi
leaq 0x45359(%rip), %rsi # 0xba669
xorl %eax, %eax
callq 0x30a0
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x18f07
leaq 0x6758d(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq (%rsp), %rcx
movq 0x2c0(%rax,%rcx), %rax
movq (%r15), %rcx
movq (%rax,%rcx,8), %rax
movq 0x60(%rsp), %rcx
incq (%rcx,%rax,8)
addq $0x8, %rbx
decq %r12
movq 0x88(%rsp), %rsi
jne 0x752b9
jmp 0x753f2
xorl %ebx, %ebx
movq 0x78(%rsp), %rax
movq (%rax,%rbx), %rax
movq %rax, 0xd0(%rsp)
movq 0x70(%rsp), %rax
movq (%rax,%rbx), %rax
movq %rax, 0xd8(%rsp)
leaq (%rsi,%rbx), %r15
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5de9b
testq %rax, %rax
jne 0x753d1
movq 0x78(%rsp), %rax
movq (%rax,%rbx), %rdx
movq 0x70(%rsp), %rax
movq (%rax,%rbx), %rcx
movq %rbp, %rdi
leaq 0x452ac(%rip), %rsi # 0xba669
xorl %eax, %eax
callq 0x30a0
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
callq 0x18f07
movq (%r15), %rax
movq 0x60(%rsp), %rcx
incq (%rcx,%rax,8)
addq $0x8, %rbx
decq %r12
movq 0x88(%rsp), %rsi
jne 0x75366
movq 0x18(%rsp), %r14
movq 0xc0(%rsp), %rax
addq %rax, %r14
movq 0x48(%rsp), %rdx
leaq (%rax,%rdx,8), %rax
movq %rax, 0xc8(%rsp)
leaq 0x6749e(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq (%rsp), %rdx
cmpl $0x0, 0x224(%rax,%rdx)
je 0x75461
testq %r13, %r13
movq 0xb0(%rsp), %rsi
jle 0x7549f
xorl %eax, %eax
xorl %r15d, %r15d
movq 0xc8(%rsp), %rdx
cmpq $0x0, (%rcx,%rax,8)
jle 0x75457
movq %rax, (%r14,%r15,8)
movq %r15, (%rdx,%rax,8)
incq %r15
incq %rax
cmpq %rax, %r13
jne 0x75445
jmp 0x754a2
movq 0x118(%rsp), %rdx
testq %rdx, %rdx
movq 0xb0(%rsp), %rsi
jle 0x7549f
xorl %eax, %eax
xorl %r15d, %r15d
movq 0xc8(%rsp), %rdi
cmpq $0x0, (%rcx,%rax,8)
jle 0x75495
movq %rax, (%r14,%r15,8)
movq %r15, (%rdi,%rax,8)
incq %r15
incq %rax
cmpq %rax, %rdx
jne 0x75483
jmp 0x754a2
xorl %r15d, %r15d
leaq 0x6746f(%rip), %rax # 0xdc918
addq %r15, 0x78(%rax)
movq %r15, %rbx
shlq $0x4, %rbx
movq %rsi, %r13
shlq $0x4, %r13
leal (%rbx,%r13), %eax
leal (%r15,%r15,4), %ecx
leal (%rax,%rcx,8), %eax
leaq (,%r15,8), %rbp
addl %ebp, %eax
movslq %eax, %rdi
callq 0x33b0
movq %rax, %r12
testq %rax, %rax
jne 0x754ef
leaq 0x401ad(%rip), %rdi # 0xb5694
movq %r15, %rsi
callq 0x18f07
movq %r14, 0x18(%rsp)
movq %r12, 0x90(%rsp)
addq %r12, %rbx
addq %rbx, %r13
movq %r13, 0x98(%rsp)
movq %rbp, 0x168(%rsp)
movq %r13, %rax
addq %rbp, %rax
movq %rax, 0x68(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0xa8(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0x48(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0xa0(%rsp)
leaq (%rax,%r15,8), %rax
movq %rax, 0x80(%rsp)
leaq 0x67367(%rip), %r13 # 0xdc8b8
movq (%r13), %rax
movq (%rsp), %rcx
cmpl $0x0, 0x224(%rax,%rcx)
movq %r15, 0x8(%rsp)
movq %rbx, 0x160(%rsp)
je 0x7562c
testq %r15, %r15
movq 0x18(%rsp), %r14
jle 0x75c0d
xorl %ebx, %ebx
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r15
movq (%r14,%rbx), %rbp
movq %r15, %rdi
movq %rbp, %rsi
leaq 0xf0(%rsp), %rdx
leaq 0xe0(%rsp), %rcx
callq 0x5f51f
movq 0xf0(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rax, (%rcx,%rbx)
movq 0xf8(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rax, (%rcx,%rbx)
movq 0xe0(%rsp), %rax
movq 0xa8(%rsp), %rcx
movq %rax, (%rcx,%rbx)
movq 0xe8(%rsp), %rax
movq 0xa0(%rsp), %rcx
movq %rax, (%rcx,%rbx)
movq 0x98(%rsp), %rax
leaq (%rax,%rbx), %rdx
movq 0x80(%rsp), %rax
leaq (%rax,%rbx), %rcx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x6c674
addq $0x8, %rbx
decq %r12
jne 0x7558e
jmp 0x75c0d
testq %r15, %r15
movq 0x18(%rsp), %r14
jle 0x75c0d
imulq $0x368, 0x10(%rsp), %rax # imm = 0x368
leaq 0xd50a8(%rax), %rcx
movq %rcx, 0x40(%rsp)
leaq 0xd5068(%rax), %rcx
movq %rcx, 0x178(%rsp)
movq %rax, 0x108(%rsp)
addq $0xd4ee0, %rax # imm = 0xD4EE0
movq %rax, 0x110(%rsp)
xorl %ebp, %ebp
movq (%r14,%rbp,8), %rsi
movq (%r13), %rax
movq (%rsp), %rbx
cmpq $0x0, 0x2a8(%rax,%rbx)
movq %r14, %r12
jle 0x7569e
addq %rbx, %rax
movq 0x2a0(%rax), %rax
movq (%rax,%rsi,8), %rsi
movq 0x68(%rsp), %r14
movq 0x10(%rsp), %rdi
leaq 0xf0(%rsp), %rdx
leaq 0xe0(%rsp), %rcx
callq 0x5f51f
movq 0xf0(%rsp), %rax
movq %rax, (%r14,%rbp,8)
movq 0xf8(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0xe0(%rsp), %rax
movq 0xa8(%rsp), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0xe8(%rsp), %rax
movq 0xa0(%rsp), %rcx
movq %rax, (%rcx,%rbp,8)
movq (%r13), %rsi
leaq (%rsi,%rbx), %r13
movq 0xc0(%rsi,%rbx), %rdx
movq 0xc8(%rsi,%rbx), %rdi
movq 0x2a8(%rsi,%rbx), %r14
movl 0x224(%rsi,%rbx), %eax
leal -0x1(%rax), %ecx
cmpl $0x3, %ecx
movq %rdx, 0x58(%rsp)
movq %rdi, 0xb8(%rsp)
jae 0x7580a
movswl (%r13), %r8d
movq (%r12,%rbp,8), %rcx
movslq %ecx, %rax
cqto
idivq 0x260(%r13)
movl %edx, 0x180(%rsp)
movl %r8d, %edi
cmpl $0x2, %r8d
jl 0x757a6
movl 0x180(%rsp), %edx
movq 0x40(%rsp), %rax
leaq (%rsi,%rax), %r9
leaq -0x1(%rdi), %r10
xorl %r11d, %r11d
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%r9,%r11,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%r9,%r11,8)
movl %edx, 0x184(%rsp,%r11,4)
incq %r11
cmpq %r11, %r10
jne 0x7577e
testw %r8w, %r8w
jle 0x75a98
addq 0x178(%rsp), %rsi
shlq $0x2, %rdi
xorl %eax, %eax
movslq 0x180(%rsp,%rax), %rcx
movq (%rsi,%rax,2), %rdx
movq %rdx, %r8
imulq %rcx, %r8
incq %r8
movq %r8, 0x120(%rsp,%rax,2)
incq %rcx
imulq %rdx, %rcx
movq %rcx, 0x20(%rsp,%rax,2)
movq -0x1f8(%rsi,%rax,2), %rdx
cmpq %rdx, %rcx
cmovgeq %rdx, %rcx
movq %rcx, 0x20(%rsp,%rax,2)
addq $0x4, %rax
cmpq %rax, %rdi
jne 0x757be
jmp 0x75a98
cmpl $0x4, %eax
je 0x75864
testl %eax, %eax
jne 0x75a98
testq %r14, %r14
je 0x7593d
movq (%r12,%rbp,8), %rax
movswq (%r13), %r15
cmpq %r14, %rax
jge 0x75a6a
testw %r15w, %r15w
jle 0x759f3
movq 0x110(%rsp), %rcx
leaq (%rsi,%rcx), %rdx
movl $0x1, %ecx
xorl %edi, %edi
movslq (%rdx,%rdi,4), %r8
imulq %r8, %rcx
incq %rdi
cmpq %rdi, %r15
jne 0x7584f
jmp 0x759f8
movswl (%r13), %r8d
movq (%r12,%rbp,8), %rcx
movslq %ecx, %rax
cqto
idivq 0x260(%r13)
movl %edx, 0x180(%rsp)
movl %r8d, %edi
cmpl $0x2, %r8d
jl 0x758c8
movl 0x180(%rsp), %edx
movq 0x40(%rsp), %rax
leaq (%rsi,%rax), %r9
leaq -0x1(%rdi), %r10
xorl %r11d, %r11d
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%r9,%r11,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%r9,%r11,8)
movl %edx, 0x184(%rsp,%r11,4)
incq %r11
cmpq %r11, %r10
jne 0x758a0
testw %r8w, %r8w
jle 0x75a98
movq 0x1e8(%rsi,%rbx), %rax
shlq $0x2, %rdi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x180(%rsp,%rcx), %r8
movslq %edx, %rsi
addq %r8, %rsi
movq (%rax,%rsi,8), %r9
movq %r9, 0x120(%rsp,%rcx,2)
movq 0x260(%r13,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x7591d
movq 0x1e8(%r13), %r8
movq 0x8(%r8,%rsi,8), %rsi
decq %rsi
jmp 0x75922
movq 0x30(%r13,%rcx,2), %rsi
movq %rsi, 0x20(%rsp,%rcx,2)
addl 0x260(%r13,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rdi
jne 0x758e2
jmp 0x75a98
movswq (%r13), %r15
testq %r15, %r15
jle 0x7596b
movq 0x110(%rsp), %rax
addq %rsi, %rax
movl $0x1, %ecx
xorl %edx, %edx
movslq (%rax,%rdx,4), %rdi
imulq %rdi, %rcx
incq %rdx
cmpq %rdx, %r15
jne 0x75959
jmp 0x75970
movl $0x1, %ecx
movq (%r12,%rbp,8), %rax
cmpq %rcx, %rax
setge %cl
testq %rax, %rax
sets %dl
orb %cl, %dl
jne 0x75a6a
testw %r15w, %r15w
jle 0x75a98
movq 0x1e8(%r13), %rcx
addq 0x108(%rsp), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%rdi,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%r8,8), %r11
movq %r11, 0x120(%rsp,%rdi,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x759d6
movq 0xd4e70(%rsi,%rdi,8), %rdx
jmp 0x759de
movq 0x8(%r10,%r8,8), %rdx
decq %rdx
addq %r9, %r8
movq %rdx, 0x20(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %r15
jne 0x759a6
jmp 0x75a98
movl $0x1, %ecx
testq %rax, %rax
js 0x75a6a
cmpq %rcx, %rax
jge 0x75a6a
testw %r15w, %r15w
jle 0x75a98
movq 0x1e8(%r13), %rcx
addq 0x108(%rsp), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x120(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x75a50
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x75a58
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
addq %r9, %rdi
movq %rdx, 0x20(%rsp,%r8,8)
incq %r8
cmpq %r8, %r15
jne 0x75a20
jmp 0x75a98
testw %r15w, %r15w
jle 0x75a98
shlq $0x3, %r15
leaq 0x120(%rsp), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3170
leaq 0x20(%rsp), %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x3170
cmpl $0x0, 0x210(%r13)
je 0x75ac0
movq (%r12,%rbp,8), %r11
testq %r14, %r14
movq 0x80(%rsp), %rdi
je 0x75ade
movq 0x2a0(%r13), %rax
movq (%rax,%r11,8), %r11
jmp 0x75ade
leaq 0x66e49(%rip), %rax # 0xdc910
movq (%rax), %rax
movq 0x18(%rax), %rax
movq (%r12,%rbp,8), %rcx
movslq (%rax,%rcx,4), %r11
movq 0x80(%rsp), %rdi
movq 0x120(%rsp), %r12
movq 0x128(%rsp), %rbx
movq 0x20(%rsp), %r13
movq 0x28(%rsp), %r10
movq 0x68(%rsp), %rax
movq (%rax,%rbp,8), %r8
cmpq %r12, %r8
setl %al
cmpq %r13, %r8
setg %cl
orb %al, %cl
movq 0x48(%rsp), %r14
jne 0x75b2c
movq (%r14,%rbp,8), %rax
cmpq %rbx, %rax
setl %cl
cmpq %r10, %rax
setg %al
orb %cl, %al
cmpb $0x1, %al
jne 0x75b81
movq 0x18(%rsp), %rax
movq (%rax,%rbp,8), %rcx
movq (%r14,%rbp,8), %r9
leaq 0x180(%rsp), %rdi
leaq 0x44a90(%rip), %rsi # 0xba5d8
leaq 0x44abb(%rip), %rdx # 0xba60a
xorl %eax, %eax
pushq %r10
pushq %rbx
pushq %r13
pushq %r12
movq %r11, %r15
callq 0x30a0
addq $0x20, %rsp
leaq 0x180(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x18f07
movq %r15, %r11
movq 0x80(%rsp), %rdi
movq 0x58(%rsp), %r9
leaq 0x1(,%r9,2), %rax
subq %r12, %rax
addq %r13, %rax
movq 0xb8(%rsp), %rdx
subq %rbx, %rdx
addq (%r14,%rbp,8), %rdx
imulq %rax, %rdx
subq %r12, %r9
movq 0x68(%rsp), %rcx
addq (%rcx,%rbp,8), %r9
addq %rdx, %r9
leaq 0x66cfb(%rip), %r13 # 0xdc8b8
movq (%r13), %rcx
movq (%rsp), %rsi
movslq 0x4(%rcx,%rsi), %rdx
shlq $0x4, %rdx
leaq 0x615ab(%rip), %r8 # 0xd7180
imulq -0x3e78(%rdx,%r8), %r9
movq 0x1e0(%rcx,%rsi), %rcx
addq (%rcx,%r11,8), %r9
movq 0x98(%rsp), %rcx
movq %r9, (%rcx,%rbp,8)
movq %rax, (%rdi,%rbp,8)
incq %rbp
cmpq 0x8(%rsp), %rbp
movq 0x18(%rsp), %r14
jne 0x75676
movq (%r13), %rax
movq (%rsp), %r9
movl 0x18(%rax,%r9), %eax
movl %eax, 0x40(%rsp)
cvtsi2sd %eax, %xmm0
movq 0xb0(%rsp), %r15
cvtsi2sd %r15, %xmm1
leaq 0x66d72(%rip), %rax # 0xdc9a8
movq (%rax), %rax
movq 0x88(%rsp), %r10
movq (%r10,%rax,8), %rax
movq 0x60(%rsp), %r11
cvtsi2sdq (%r11,%rax,8), %xmm2
unpcklpd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
leaq 0x66bfd(%rip), %rax # 0xdc858
movupd 0x40(%rax), %xmm2
unpcklpd %xmm0, %xmm0 # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
addpd %xmm2, %xmm0
movupd %xmm0, 0x40(%rax)
movq 0x90(%rsp), %rbx
movq 0x160(%rsp), %rax
movq %rax, (%rbx)
leaq (%rax,%r15,8), %rax
movq 0x8(%rsp), %rdx
movq %rax, (%rbx,%rdx,8)
cmpq $0x2, %rdx
movq 0x168(%rsp), %r12
jl 0x75cd4
movq (%rbx), %rax
movq (%rbx,%rdx,8), %rcx
decq %rdx
leaq (%r12,%rbx), %rsi
addq $0x8, %rsi
xorl %edi, %edi
movq (%r14,%rdi,8), %r8
movq (%r11,%r8,8), %r8
leaq (%rax,%r8,8), %rax
movq %rax, 0x8(%rbx,%rdi,8)
leaq (%rcx,%r8,8), %rcx
movq %rcx, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x75cb3
addq %r12, %rbx
movq %rbx, 0x58(%rsp)
cmpq $0x2, %r15
movl $0x1, %eax
cmovgeq %r15, %rax
movq %rax, 0xb8(%rsp)
movslq 0x40(%rsp), %r12
xorl %r15d, %r15d
movq 0x170(%rsp), %rsi
movq 0xc0(%rsp), %rdi
movq 0x98(%rsp), %r8
movq 0x68(%rsp), %r11
movq 0x48(%rsp), %r14
movq (%r10,%r15,8), %rax
leaq 0x66b92(%rip), %rcx # 0xdc8b8
movq (%rcx), %rcx
cmpq $0x0, 0x2a8(%rcx,%r9)
jle 0x75d42
addq %r9, %rcx
movq 0x2c0(%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq (%rdi,%rax,8), %rbx
leaq 0x1(%rbx), %rcx
movq %rcx, (%rdi,%rax,8)
movq 0xc8(%rsp), %rcx
movq (%rcx,%rax,8), %rbp
movq 0x58(%rsp), %rax
movq (%rax,%rbp,8), %rax
movq %rsi, (%rax,%rbx,8)
movq 0x78(%rsp), %rax
movq (%rax,%r15,8), %rcx
movq (%r11,%rbp,8), %r9
cmpq %r9, %rcx
jl 0x75da8
movq 0xa8(%rsp), %rax
cmpq (%rax,%rbp,8), %rcx
jg 0x75da8
movq 0x70(%rsp), %rax
movq (%rax,%r15,8), %rax
cmpq (%r14,%rbp,8), %rax
jl 0x75da8
movq 0xa0(%rsp), %rdx
cmpq (%rdx,%rbp,8), %rax
jle 0x75e2a
movq 0x70(%rsp), %rax
movq (%rax,%r15,8), %r8
subq $0x8, %rsp
leaq 0x188(%rsp), %r13
movq %r13, %rdi
movq %rsi, %r14
leaq 0x448b5(%rip), %rsi # 0xba67f
movl %ebp, %edx
xorl %eax, %eax
movq 0xa8(%rsp), %r10
pushq (%r10,%rbp,8)
movq 0x58(%rsp), %r10
pushq (%r10,%rbp,8)
movq 0xc0(%rsp), %r10
pushq (%r10,%rbp,8)
callq 0x30a0
addq $0x20, %rsp
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x18f07
movq 0x98(%rsp), %r8
movq 0xc0(%rsp), %rdi
movq %r14, %rsi
movq 0x48(%rsp), %r14
movq 0x68(%rsp), %r11
movq 0x88(%rsp), %r10
movq 0x70(%rsp), %rax
movq (%rax,%r15,8), %rax
subq (%r14,%rbp,8), %rax
movq 0x80(%rsp), %rcx
imulq (%rcx,%rbp,8), %rax
movq 0x78(%rsp), %rcx
addq (%rcx,%r15,8), %rax
subq (%r11,%rbp,8), %rax
imulq %r12, %rax
addq (%r8,%rbp,8), %rax
movq 0x90(%rsp), %rdx
movq (%rdx,%rbp,8), %rcx
movq %rax, (%rcx,%rbx,8)
incq %r15
addq %r12, %rsi
cmpq %r15, 0xb8(%rsp)
movq (%rsp), %r9
jne 0x75d1b
movq %rdx, %rbp
leaq 0x66a2d(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movl 0x224(%rax,%r9), %eax
cmpq $0x4, %rax
movq 0x50(%rsp), %rsi
ja 0x763be
leaq 0x44424(%rip), %rcx # 0xba2d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x8(%rsp)
jle 0x763be
imulq $0x368, 0x10(%rsp), %r15 # imm = 0x368
leaq 0xd50a8(%r15), %r12
addq $0xd4ee0, %r15 # imm = 0xD4EE0
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbx
leaq 0x4481f(%rip), %r14 # 0xba706
movl 0x40(%rsp), %eax
movl %eax, 0x34(%rsp)
movq (%rbp,%r13,8), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax,%r13,8), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r13,8), %rsi
movq 0x60(%rsp), %rax
movl (%rax,%rsi,8), %eax
movl %eax, 0x30(%rsp)
leaq 0x66995(%rip), %rax # 0xdc8b8
movq (%rax), %rdi
movq (%rsp), %rcx
movswl (%rdi,%rcx), %r8d
movslq %esi, %rax
cqto
idivq 0x260(%rdi,%rcx)
movq %rdx, %rcx
movq %rdx, 0x180(%rsp)
movl %r8d, %r9d
cmpl $0x2, %r8d
jl 0x75f86
leaq (%rdi,%r12), %r10
leaq -0x1(%r9), %r11
xorl %ebp, %ebp
movq %rcx, %rdx
movslq %esi, %rax
subq %rdx, %rax
cqto
idivq -0x8(%r10,%rbp,8)
movq %rax, %rsi
movslq %esi, %rax
cqto
idivq (%r10,%rbp,8)
movq %rdx, 0x188(%rsp,%rbp,8)
incq %rbp
cmpq %rbp, %r11
jne 0x75f5d
movslq %r8d, %rsi
movq (%rsp), %r11
movslq 0xa0(%rdi,%r11), %r10
movq %rcx, %rax
cqto
idivq %r10
movq %rdx, 0x180(%rsp)
movq 0x188(%rsp), %rax
movslq 0xa4(%rdi,%r11), %rcx
cqto
idivq %rcx
movq %rdx, 0x188(%rsp)
testw %si, %si
jle 0x75fef
leaq (%rdi,%r15), %rcx
xorl %r10d, %r10d
movq 0x180(%rsp,%r10,8), %rax
movslq (%rcx,%r10,4), %r11
cqto
idivq %r11
movq %rdx, 0x120(%rsp,%r10,8)
incq %r10
cmpq %r10, %r9
jne 0x75fce
movq 0x118(%rsp,%rsi,8), %rax
cmpw $0x2, %r8w
jl 0x7602b
addl $-0x2, %r8d
addq %r15, %rdi
movq 0x50(%rsp), %rsi
movslq (%rdi,%r8,4), %rdx
imulq %rax, %rdx
addq 0x120(%rsp,%r8,8), %rdx
leaq -0x1(%r8), %rcx
movq %rdx, %rax
testq %r8, %r8
movq %rcx, %r8
jg 0x7600a
jmp 0x76033
movq %rax, %rdx
movq 0x50(%rsp), %rsi
testl %esi, %esi
movq 0x90(%rsp), %rbp
js 0x76055
leaq 0x668ca(%rip), %rax # 0xdc910
movq (%rax), %rax
leaq (%rsi,%rsi,4), %rcx
movq 0x18(%rax,%rcx,8), %rax
movl (%rax,%rdx,4), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58f93
testl %eax, %eax
je 0x76071
movslq %eax, %rsi
movq %r14, %rdi
callq 0x18f07
incq %r13
cmpq 0x8(%rsp), %r13
jne 0x75ee7
jmp 0x763be
cmpq $0x0, 0x8(%rsp)
jle 0x763be
imulq $0x368, 0x10(%rsp), %r15 # imm = 0x368
leaq 0xd50a8(%r15), %r12
addq $0xd4ee0, %r15 # imm = 0xD4EE0
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbx
leaq 0x44650(%rip), %r14 # 0xba706
movl 0x40(%rsp), %eax
movl %eax, 0x34(%rsp)
movq (%rbp,%r13,8), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax,%r13,8), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r13,8), %rsi
movq 0x60(%rsp), %rax
movl (%rax,%rsi,8), %eax
movl %eax, 0x30(%rsp)
leaq 0x667c6(%rip), %rax # 0xdc8b8
movq (%rax), %rdi
movq (%rsp), %rcx
movswl (%rdi,%rcx), %r8d
movslq %esi, %rax
cqto
idivq 0x260(%rdi,%rcx)
movq %rdx, %rcx
movq %rdx, 0x180(%rsp)
movl %r8d, %r9d
cmpl $0x2, %r8d
jl 0x76155
leaq (%rdi,%r12), %r10
leaq -0x1(%r9), %r11
xorl %ebp, %ebp
movq %rcx, %rdx
movslq %esi, %rax
subq %rdx, %rax
cqto
idivq -0x8(%r10,%rbp,8)
movq %rax, %rsi
movslq %esi, %rax
cqto
idivq (%r10,%rbp,8)
movq %rdx, 0x188(%rsp,%rbp,8)
incq %rbp
cmpq %rbp, %r11
jne 0x7612c
movslq %r8d, %rsi
movq (%rsp), %r11
movslq 0xa0(%rdi,%r11), %r10
movq %rcx, %rax
cqto
idivq %r10
movq %rdx, 0x180(%rsp)
movq 0x188(%rsp), %rax
movslq 0xa4(%rdi,%r11), %rcx
cqto
idivq %rcx
movq %rdx, 0x188(%rsp)
testw %si, %si
jle 0x761be
leaq (%rdi,%r15), %rcx
xorl %r10d, %r10d
movq 0x180(%rsp,%r10,8), %rax
movslq (%rcx,%r10,4), %r11
cqto
idivq %r11
movq %rdx, 0x120(%rsp,%r10,8)
incq %r10
cmpq %r10, %r9
jne 0x7619d
movq 0x118(%rsp,%rsi,8), %rax
cmpw $0x2, %r8w
jl 0x761fa
addl $-0x2, %r8d
addq %r15, %rdi
movq 0x50(%rsp), %rsi
movslq (%rdi,%r8,4), %rdx
imulq %rax, %rdx
addq 0x120(%rsp,%r8,8), %rdx
leaq -0x1(%r8), %rcx
movq %rdx, %rax
testq %r8, %r8
movq %rcx, %r8
jg 0x761d9
jmp 0x76202
movq %rax, %rdx
movq 0x50(%rsp), %rsi
testl %esi, %esi
movq 0x90(%rsp), %rbp
js 0x76224
leaq 0x666fb(%rip), %rax # 0xdc910
movq (%rax), %rax
leaq (%rsi,%rsi,4), %rcx
movq 0x18(%rax,%rcx,8), %rax
movl (%rax,%rdx,4), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58f93
testl %eax, %eax
je 0x76240
movslq %eax, %rsi
movq %r14, %rdi
callq 0x18f07
incq %r13
cmpq 0x8(%rsp), %r13
jne 0x760b6
jmp 0x763be
cmpq $0x0, 0x8(%rsp)
jle 0x763be
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbx
leaq 0x44498(%rip), %r14 # 0xba706
leaq 0x6669b(%rip), %r12 # 0xdc910
leaq (%rsi,%rsi,4), %r13
movl 0x40(%rsp), %eax
movl %eax, 0x34(%rsp)
movq (%rbp,%r15,8), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax,%r15,8), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r15,8), %rdx
movq 0x60(%rsp), %rax
movl (%rax,%rdx,8), %eax
movl %eax, 0x30(%rsp)
testl %esi, %esi
js 0x762c0
movq (%r12), %rax
movq 0x18(%rax,%r13,8), %rax
movl (%rax,%rdx,4), %edx
jmp 0x762e7
leaq 0x665f1(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq (%rsp), %rcx
cmpq $0x0, 0x2a8(%rax,%rcx)
jle 0x762e7
addq %rcx, %rax
movq 0x2a0(%rax), %rax
movq (%rax,%rdx,8), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58f93
testl %eax, %eax
je 0x76303
movslq %eax, %rsi
movq %r14, %rdi
callq 0x18f07
incq %r15
cmpq %r15, 0x8(%rsp)
movq 0x50(%rsp), %rsi
jne 0x76279
jmp 0x763be
cmpq $0x0, 0x8(%rsp)
jle 0x763be
xorl %r15d, %r15d
leaq 0x665df(%rip), %r12 # 0xdc910
leaq (%rsi,%rsi,4), %r13
leaq 0x20(%rsp), %rbx
leaq 0x443c5(%rip), %r14 # 0xba706
movl 0x40(%rsp), %eax
movl %eax, 0x34(%rsp)
movq (%rbp,%r15,8), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq (%rax,%r15,8), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq (%rax,%r15,8), %rcx
movq %rcx, %rax
cqto
idivq 0x118(%rsp)
movq 0x60(%rsp), %rax
movl (%rax,%rcx,8), %eax
movl %eax, 0x30(%rsp)
testl %esi, %esi
js 0x76393
movq (%r12), %rax
movq 0x18(%rax,%r13,8), %rax
movl (%rax,%rdx,4), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58f93
testl %eax, %eax
je 0x763af
movslq %eax, %rsi
movq %r14, %rdi
callq 0x18f07
incq %r15
cmpq %r15, 0x8(%rsp)
movq 0x50(%rsp), %rsi
jne 0x76341
movq %rbp, %rdi
callq 0x3330
movq 0x88(%rsp), %rdi
callq 0x3330
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/onesided.c |
pnga_msg_brdcst | void pnga_msg_brdcst(Integer type, void *buffer, Integer len, Integer root)
{
long bigint = 2147483647L;
int i, nsteps;//= (int) ceil(((double)len)/((double)bigint));
long len_small;
void *buffer_ptr;
long istart=0;
int p_grp;
/* printf("%ld len %ld bigint %ld \n",GAme,len,bigint); */
nsteps = (int) ceil(((double)len)/((double)bigint));
/* printf("%ld len %ld bigint %ld nsteps %d \n",GAme,len,bigint,nsteps); */
for (i=0; i < nsteps; i++){
len_small=bigint;
buffer_ptr=(char *)buffer+istart;
if (istart+len_small > len) len_small=((long)(len - istart));
/* printf("%ld step %d of %d len= %d total=%ld istart= %ld\n",GAme,(i+1),nsteps,len_small,len,istart); */
p_grp = (int)pnga_pgroup_get_default();
if (p_grp > 0) {
# ifdef MSG_COMMS_MPI
int aroot = PGRP_LIST[p_grp].inv_map_proc_list[root];
armci_msg_group_bcast_scope(SCOPE_ALL,buffer_ptr, (int)len_small, aroot,(&(PGRP_LIST[p_grp].group)));
# endif
} else {
armci_msg_bcast(buffer_ptr, (int)len_small, (int)root);
}
istart+=len_small;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
cvtsi2sd %rdx, %xmm0
divsd 0x4141c(%rip), %xmm0 # 0xb92d0
callq 0x3070
cvttsd2si %xmm0, %ebp
testl %ebp, %ebp
jle 0x77f3e
movl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
xorl %r15d, %r15d
movq 0x10(%rsp), %rax
leaq (%rax,%r15), %r13
leaq (%r15,%rbx), %rax
movq %r14, %r12
subq %r15, %r12
cmpq %r14, %rax
cmovleq %rbx, %r12
xorl %eax, %eax
callq 0x5ff7f
testl %eax, %eax
jle 0x77f27
leaq 0x64a1b(%rip), %rcx # 0xdc910
movq (%rcx), %rcx
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
leaq (%rax,%rax,4), %rax
leaq (%rcx,%rax,8), %r8
addq $0x20, %r8
movq -0x8(%r8), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movl $0x14d, %edi # imm = 0x14D
movq %r13, %rsi
movl %r12d, %edx
callq 0x5a2d3
jmp 0x77f37
movq %r13, %rdi
movl %r12d, %esi
movq 0x8(%rsp), %rdx
callq 0x59148
addq %r12, %r15
decl %ebp
jne 0x77ec9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/collect.c |
GA_MPI_Comm_pgroup | MPI_Comm GA_MPI_Comm_pgroup(int p_grp)
{
ARMCI_Group group;
if (p_grp > 0) {
group = PGRP_LIST[p_grp].group;
}
else {
ARMCI_Group_get_world(&group);
}
# if HAVE_ARMCI_GROUP_COMM_MEMBER
return group.comm;
# else
return armci_group_comm(&group);
# endif
} | pushq %rax
testl %edi, %edi
jle 0x78004
leaq 0x6491f(%rip), %rax # 0xdc910
movq (%rax), %rax
movl %edi, %ecx
leaq (%rcx,%rcx,4), %rcx
movl 0x20(%rax,%rcx,8), %eax
movl %eax, 0x4(%rsp)
jmp 0x7800e
leaq 0x4(%rsp), %rdi
callq 0x590e8
leaq 0x4(%rsp), %rdi
callq 0x59114
popq %rcx
retq
| /GlobalArrays[P]ga/global/src/collect.c |
pnga_update1_ghosts | void pnga_update1_ghosts(Integer g_a)
{
Integer idx, ipx, inx, i, np, handle=GA_OFFSET + g_a, proc_rem;
Integer size, ndim, nwidth, offset, slice, increment[MAXDIM];
Integer width[MAXDIM];
Integer dims[MAXDIM], imax=0;
Integer lo_loc[MAXDIM], hi_loc[MAXDIM];
Integer plo_loc[MAXDIM]/*, phi_loc[MAXDIM]*/;
Integer lo_rem[MAXDIM], hi_rem[MAXDIM];
Integer tlo_rem[MAXDIM], thi_rem[MAXDIM];
Integer slo_rem[MAXDIM], shi_rem[MAXDIM];
Integer plo_rem[MAXDIM], phi_rem[MAXDIM];
Integer ld_loc[MAXDIM], ld_rem[MAXDIM];
int corner_flag;
int stride_loc[MAXDIM], stride_rem[MAXDIM], count[MAXDIM];
char *ptr_loc, *ptr_rem;
logical hasData = TRUE;
Integer me = pnga_nodeid();
Integer p_handle;
Integer *_ga_map = NULL;
Integer *_ga_proclist = NULL;
/* This routine makes use of the shift algorithm to update data in the
* ghost cells bounding the local block of visible data. The shift
* algorithm starts by updating the blocks of data along the first
* dimension by grabbing a block of data that is width[0] deep but
* otherwise matches the dimensions of the data residing on the
* calling processor. The update of the second dimension, however,
* grabs a block that is width[1] deep in the second dimension but is
* ldim0 + 2*width[0] in the first dimensions where ldim0 is the
* size of the visible data along the first dimension. The remaining
* dimensions are left the same. For the next update, the width of the
* second dimension is also increased by 2*width[1] and so on. This
* algorith makes use of the fact that data for the dimensions that
* have already been updated is available on each processor and can be
* used in the updates of subsequent dimensions. The total number of
* separate updates is 2*ndim, an update in the negative and positive
* directions for each dimension.
*
* To perform the update, this routine makes use of several copies of
* indices marking the upper and lower limits of data. Indices
* beginning with the character "p" are relative indices marking the
* location of the data set relative to the origin the local patch of
* the global array, all other indices are in absolute coordinates and
* mark locations in the total global array. The indices used by this
* routine are described below.
*
* lo_loc[], hi_loc[]: The lower and upper indices of the visible
* block of data held by the calling processor.
*
* lo_rem[], hi_rem[]: The lower and upper indices of the block
* of data on a remote processor or processors that is needed to
* fill in the calling processors ghost cells. These indices are
* NOT corrected for wrap-around (periodic) boundary conditions
* so they can be negative or greater than the array dimension
* values held in dims[].
*
* slo_rem[], shi_rem[]: Similar to lo_rem[] and hi_rem[], except
* that these indices have been corrected for wrap-around
* boundary conditions. If lo_rem[] and hi_rem[] cross a global
* array boundary, as opposed to being entirely located on one
* side or the other of the array, then two sets of slo_rem[] and
* shi_rem[] will be created. One set will correspond to the
* block of data on one side of the global array boundary and the
* other set will correspond to the remaining block. This
* situation will only occur if the value of the ghost cell width
* is greater than the dimension of the visible global array
* data on a single processor.
*
* thi_rem[], thi_rem[]: The lower and upper indices of the visible
* data on a remote processor.
*
* plo_loc[], phi_loc[]: The indices of the local data patch that
* is going to be updated.
*
* plo_rem[], phi_rem[]: The indices of the data patch on the
* remote processor that will be used to update the data on the
* calling processor. Note that the dimensions of the patches
* represented by plo_loc[], plo_rem[] and plo_loc[], phi_loc[]
* must be the same.
*
* For the case where the width of the ghost cells is more than the
* width of the visible data held on a processor, special problems
* arise. It now takes several updates to fill in one block of boundary
* data and it is now necessary to keep track of where each of these
* blocks of data go in the ghost cell region. To do this two extra
* variables are needed. These are offset and slice. Slice is equal to
* the width of the visible data along the dimension being updated
* minus one coming from the remote processor. Offset is the amount
* that this data must be moved inward from the lower boundary of the
* ghost cell region. Another variable that is also used to handle
* this case is imax. If this variable is set to 2, then this means
* that the block of data that is needed to update the ghost cells
* crosses a global array boundary and the block needs to be broken
* up into two pieces. */
/* if global array has no ghost cells, just return */
if (!pnga_has_ghosts(g_a)) return;
_ga_map = malloc((GAnproc*2*MAXDIM +1)*sizeof(Integer));
if(!_ga_map) pnga_error("pnga_update1_ghosts:malloc failed (_ga_map)",0);
_ga_proclist = malloc(GAnproc*sizeof(Integer));
if(!_ga_proclist) pnga_error("pnga_update1_ghosts:malloc failed (_ga_proclist)",0);
size = GA[handle].elemsize;
ndim = GA[handle].ndim;
corner_flag = GA[handle].corner_flag;
p_handle = GA[handle].p_handle;
/* Get pointer to local memory */
ptr_loc = GA[handle].ptr[me];
/* obtain range of data that is held by local processor */
pnga_distribution(g_a,me,lo_loc,hi_loc);
/* initialize range increments and get array dimensions */
for (idx=0; idx < ndim; idx++) {
increment[idx] = 0;
width[idx] = (Integer)GA[handle].width[idx];
dims[idx] = (Integer)GA[handle].dims[idx];
if (lo_loc[idx] == 0 && hi_loc[idx] == -1) hasData = FALSE;
}
/* loop over dimensions for sequential update using shift algorithm */
for (idx=0; idx < ndim; idx++) {
nwidth = (Integer)width[idx];
/* Do not bother with update if nwidth is zero or processor has
no data */
if (nwidth != 0 && hasData) {
/* Perform update in negative direction. Start by getting rough
estimate of block of needed data*/
for (i = 0; i < ndim; i++) {
if (i == idx) {
lo_rem[i] = lo_loc[i] - nwidth;
hi_rem[i] = lo_loc[i] - 1;
/* Check to see if we will need to update ghost cells using
one or two major patches of the global array. */
if (lo_rem[i] < 1) {
if (hi_rem[i] > 0) {
imax = 2;
} else {
imax = 1;
}
} else {
imax = 1;
}
} else {
lo_rem[i] = lo_loc[i];
hi_rem[i] = hi_loc[i];
}
}
for (inx = 0; inx < imax; inx++) {
/* Check to see if boundary is being updated in one patch or two,
adjust lower boundary accordingly. */
for (i=0; i<ndim; i++) {
if (imax == 2 && i == idx) {
if (inx == 0) {
slo_rem[i] = 1;
shi_rem[i] = hi_rem[i];
} else {
slo_rem[i] = lo_rem[i] + dims[i];
shi_rem[i] = dims[i];
}
} else if (i == idx) {
if (lo_rem[i] < 1) {
slo_rem[i] = dims[i] - nwidth + 1;
shi_rem[i] = dims[i];
} else {
slo_rem[i] = lo_rem[i];
shi_rem[i] = hi_rem[i];
}
} else {
slo_rem[i] = lo_rem[i];
shi_rem[i] = hi_rem[i];
}
}
/* locate processor with this data */
if (!pnga_locate_region(g_a, slo_rem, shi_rem, _ga_map,
_ga_proclist, &np)) ga_RegionError(pnga_ndim(g_a),
slo_rem, shi_rem, g_a);
for (ipx = 0; ipx < np; ipx++) {
/* Get actual coordinates of desired chunk of remote
data as well as the actual coordinates of the local chunk
of data that will receive the remote data (these
coordinates take into account the presence of ghost
cells). Start by finding out what data is actually held by
remote processor. */
proc_rem = _ga_proclist[ipx];
pnga_distribution(g_a, proc_rem, tlo_rem, thi_rem);
for (i = 0; i < ndim; i++) {
if (increment[i] == 0) {
if (i == idx) {
if (np == 1 && imax == 1) {
plo_rem[i] = thi_rem[i] - tlo_rem[i] + 1;
phi_rem[i] = thi_rem[i] - tlo_rem[i] + width[i];
plo_loc[i] = 0;
/*phi_loc[i] = width[i] - 1;*/
} else {
if (tlo_rem[i] >= slo_rem[i]) {
offset = tlo_rem[i] - lo_rem[i];
slice = thi_rem[i] - tlo_rem[i];
} else {
offset = 0;
slice = thi_rem[i] - slo_rem[i];
}
if (offset < 0) offset = offset + dims[i];
if (offset >= dims[i]) offset = offset - dims[i];
plo_rem[i] = thi_rem[i] - tlo_rem[i] + width[i] - slice;
phi_rem[i] = thi_rem[i] - tlo_rem[i] + width[i];
plo_loc[i] = offset;
/*phi_loc[i] = offset + slice;*/
}
} else {
plo_rem[i] = width[i];
phi_rem[i] = thi_rem[i] - tlo_rem[i] + width[i];
plo_loc[i] = width[i];
/*phi_loc[i] = hi_loc[i] - lo_loc[i] + width[i];*/
}
} else {
plo_rem[i] = 0;
phi_rem[i] = thi_rem[i] - tlo_rem[i] + increment[i];
plo_loc[i] = 0;
/*phi_loc[i] = hi_loc[i] - lo_loc[i] + increment[i];*/
}
}
/* Get pointer to local data buffer and remote data
buffer as well as lists of leading dimenstions */
gam_LocationWithGhosts(me, handle, plo_loc, &ptr_loc, ld_loc);
gam_LocationWithGhosts(proc_rem, handle, plo_rem, &ptr_rem, ld_rem);
/* Evaluate strides on local and remote processors */
gam_setstride(ndim, size, ld_loc, ld_rem, stride_rem,
stride_loc);
/* Compute the number of elements in each dimension and store
result in count. Scale the first element in count by the
element size. */
gam_ComputeCount(ndim, plo_rem, phi_rem, count);
count[0] *= size;
/* get remote data */
if (p_handle >= 0) {
proc_rem = PGRP_LIST[p_handle].inv_map_proc_list[proc_rem];
}
ARMCI_GetS(ptr_rem, stride_rem, ptr_loc, stride_loc, count,
(int)(ndim - 1), (int)proc_rem);
}
}
/* Perform update in positive direction. Start by getting rough
estimate of block of needed data*/
for (i = 0; i < ndim; i++) {
if (i == idx) {
lo_rem[i] = hi_loc[i] + 1;
hi_rem[i] = hi_loc[i] + nwidth;
/* Check to see if we will need to update ghost cells using
one or two major patches of the global array. */
if (hi_rem[i] > dims[i]) {
if (lo_rem[i] <= dims[i]) {
imax = 2;
} else {
imax = 1;
}
} else {
imax = 1;
}
} else {
lo_rem[i] = lo_loc[i];
hi_rem[i] = hi_loc[i];
}
}
for (inx = 0; inx < imax; inx++) {
/* Check to see if boundary is being updated in one patch or two,
adjust lower boundary accordingly. */
for (i=0; i<ndim; i++) {
if (imax == 2 && i == idx) {
if (inx == 0) {
slo_rem[i] = lo_rem[i];
shi_rem[i] = dims[i];
} else {
slo_rem[i] = 1;
shi_rem[i] = hi_rem[i] - dims[i];
}
} else if (i == idx) {
if (hi_rem[i] > dims[i]) {
slo_rem[i] = 1;
shi_rem[i] = nwidth;
} else {
slo_rem[i] = lo_rem[i];
shi_rem[i] = hi_rem[i];
}
} else {
slo_rem[i] = lo_rem[i];
shi_rem[i] = hi_rem[i];
}
}
/* locate processor with this data */
if (!pnga_locate_region(g_a, slo_rem, shi_rem, _ga_map,
_ga_proclist, &np)) ga_RegionError(pnga_ndim(g_a),
slo_rem, shi_rem, g_a);
for (ipx = 0; ipx < np; ipx++) {
/* Get actual coordinates of desired chunk of remote
data as well as the actual coordinates of the local chunk
of data that will receive the remote data (these
coordinates take into account the presence of ghost
cells). Start by finding out what data is actually held by
remote processor. */
proc_rem = _ga_proclist[ipx];
pnga_distribution(g_a, proc_rem, tlo_rem, thi_rem);
for (i = 0; i < ndim; i++) {
if (increment[i] == 0) {
if (i == idx) {
if (np == 1 && imax == 1) {
plo_rem[i] = width[i];
phi_rem[i] = 2*width[i] - 1;
plo_loc[i] = hi_loc[i] - lo_loc[i] + 1 + width[i];
/*phi_loc[i] = hi_loc[i] - lo_loc[i] + 2*width[i];*/
} else {
offset = tlo_rem[i] - hi_loc[i] - 1;
if (thi_rem[i] <= shi_rem[i]) {
slice = thi_rem[i] - tlo_rem[i];
} else {
slice = shi_rem[i] - tlo_rem[i];
}
if (offset < 0) offset = offset + dims[i];
if (offset >= dims[i]) offset = offset - dims[i];
plo_rem[i] = width[i];
phi_rem[i] = width[i] + slice;
plo_loc[i] = hi_loc[i] - lo_loc[i] + width[i] + 1 + offset;
/*phi_loc[i] = hi_loc[i] - lo_loc[i] + width[i] + 1
+ offset + slice;*/
}
} else {
plo_rem[i] = width[i];
phi_rem[i] = thi_rem[i] - tlo_rem[i] + width[i];
plo_loc[i] = width[i];
/*phi_loc[i] = hi_loc[i] - lo_loc[i] + width[i];*/
}
} else {
plo_rem[i] = 0;
phi_rem[i] = thi_rem[i] - tlo_rem[i] + increment[i];
plo_loc[i] = 0;
/*phi_loc[i] = hi_loc[i] - lo_loc[i] + increment[i];*/
}
}
/* Get pointer to local data buffer and remote data
buffer as well as lists of leading dimenstions */
gam_LocationWithGhosts(me, handle, plo_loc, &ptr_loc, ld_loc);
gam_LocationWithGhosts(proc_rem, handle, plo_rem, &ptr_rem, ld_rem);
/* Evaluate strides on local and remote processors */
gam_setstride(ndim, size, ld_loc, ld_rem, stride_rem,
stride_loc);
/* Compute the number of elements in each dimension and store
result in count. Scale the first element in count by the
element size. */
gam_ComputeCount(ndim, plo_rem, phi_rem, count);
count[0] *= size;
/* get remote data */
if (p_handle >= 0) {
proc_rem = PGRP_LIST[p_handle].inv_map_proc_list[proc_rem];
}
ARMCI_GetS(ptr_rem, stride_rem, ptr_loc, stride_loc, count,
(int)(ndim - 1), (int)proc_rem);
}
}
}
/* synchronize all processors and update increment array */
if (idx < ndim-1) pnga_pgroup_sync(p_handle);
if (corner_flag)
increment[idx] = 2*nwidth;
}
free(_ga_map);
free(_ga_proclist);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6a8, %rsp # imm = 0x6A8
movq %rdi, %r12
xorl %eax, %eax
callq 0x685c6
movq %rax, 0x18(%rsp)
movq %r12, %rdi
callq 0x652f9
testq %rax, %rax
je 0x7b4d6
leaq 0x632e7(%rip), %r14 # 0xdc998
imulq $0x70, (%r14), %rdi
orq $0x8, %rdi
callq 0x33b0
movq %rax, 0xf8(%rsp)
testq %rax, %rax
jne 0x796d9
leaq 0x41336(%rip), %rdi # 0xbaa08
xorl %esi, %esi
callq 0x18f07
leaq 0x3e8(%r12), %rbx
movq (%r14), %rdi
shlq $0x3, %rdi
callq 0x33b0
movq %rax, 0x80(%rsp)
testq %rax, %rax
jne 0x79708
leaq 0x41333(%rip), %rdi # 0xbaa34
xorl %esi, %esi
callq 0x18f07
leaq 0x631a9(%rip), %r13 # 0xdc8b8
movq (%r13), %rax
imulq $0x368, %rbx, %rcx # imm = 0x368
movl 0x18(%rax,%rcx), %edx
movl %edx, 0x2c(%rsp)
movswq (%rax,%rcx), %r14
movl 0x220(%rax,%rcx), %edx
movl %edx, 0x130(%rsp)
movq %rcx, 0x20(%rsp)
movslq 0x210(%rax,%rcx), %rax
movq %rax, 0x128(%rsp)
leaq 0x630(%rsp), %rdx
leaq 0x530(%rsp), %rcx
movq %r12, %rdi
movq 0x18(%rsp), %rsi
callq 0x5f51f
testq %r14, %r14
jle 0x797dc
movq (%r13), %rax
imulq $0x368, %r12, %rcx # imm = 0x368
addq %rax, %rcx
addq $0xd4f00, %rcx # imm = 0xD4F00
movl $0x1, %eax
xorl %edx, %edx
xorl %esi, %esi
movq $0x0, 0x670(%rsp,%rsi,8)
movq (%rcx,%rsi,8), %rdi
movq %rdi, 0x4b0(%rsp,%rsi,8)
movq -0x90(%rcx,%rsi,8), %rdi
movq %rdi, 0x330(%rsp,%rsi,8)
cmpq $0x0, 0x630(%rsp,%rsi,8)
jne 0x797ca
cmpq $-0x1, 0x530(%rsp,%rsi,8)
cmoveq %rdx, %rax
incq %rsi
cmpq %rsi, %r14
jne 0x7978a
testq %rax, %rax
setne 0xf(%rsp)
jmp 0x797e1
movb $0x1, 0xf(%rsp)
movq 0x18(%rsp), %rax
testw %r14w, %r14w
jle 0x7b4bc
cltq
movq %rax, 0xd8(%rsp)
leaq -0x1(%r14), %rax
leal -0x1(%r14), %ecx
movl %ecx, 0x134(%rsp)
cmpq $0x2, %rax
movl $0x1, %ecx
movq %rax, 0x138(%rsp)
cmovgeq %rax, %rcx
movq %rcx, 0x140(%rsp)
imulq $0x368, %r12, %rcx # imm = 0x368
leaq 0xd50a8(%rcx), %rax
movq %rax, 0x68(%rsp)
leaq 0xd5068(%rcx), %rax
movq %rax, 0xd0(%rsp)
leaq 0xd4ee0(%rcx), %rax
movq %rax, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
leaq 0xd4f00(%rcx), %rax
movq %rax, 0xe0(%rsp)
xorl %r15d, %r15d
xorl %ebx, %ebx
movq %r12, 0x148(%rsp)
movq 0x4b0(%rsp,%r15,8), %rdi
testq %rdi, %rdi
setne %al
andb 0xf(%rsp), %al
cmpb $0x1, %al
movq %rdi, 0x100(%rsp)
jne 0x7b47c
xorl %eax, %eax
movq 0x630(%rsp,%rax,8), %rcx
cmpq %rax, %r15
jne 0x798d5
leaq -0x1(%rcx), %rdx
movq %rcx, %rsi
movq %rdx, 0x3b0(%rsp,%rax,8)
movl $0x1, %ebx
subq %rdi, %rsi
movq %rsi, 0x3f0(%rsp,%rax,8)
jg 0x798ed
xorl %ebx, %ebx
cmpq $0x2, %rcx
setge %bl
incq %rbx
jmp 0x798ed
movq %rcx, 0x3f0(%rsp,%rax,8)
movq 0x530(%rsp,%rax,8), %rcx
movq %rcx, 0x3b0(%rsp,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x79899
testq %rbx, %rbx
movq %r15, 0xe8(%rsp)
jle 0x7a660
xorl %esi, %esi
xorl %eax, %eax
movq %rbx, %rcx
xorq $0x2, %rcx
movq %r15, %rdx
xorq %rax, %rdx
orq %rcx, %rdx
jne 0x79936
testq %rsi, %rsi
je 0x79952
movq 0x330(%rsp,%rax,8), %rcx
movq 0x3f0(%rsp,%rax,8), %rdx
addq %rcx, %rdx
jmp 0x79979
movq 0x3f0(%rsp,%rax,8), %rcx
cmpq %rax, %r15
jne 0x79948
testq %rcx, %rcx
jle 0x79968
movq %rcx, 0x190(%rsp,%rax,8)
jmp 0x7995e
movq $0x1, 0x190(%rsp,%rax,8)
movq 0x3b0(%rsp,%rax,8), %rcx
jmp 0x79981
movq 0x330(%rsp,%rax,8), %rcx
movq %rcx, %rdx
subq %rdi, %rdx
incq %rdx
movq %rdx, 0x190(%rsp,%rax,8)
movq %rcx, 0x430(%rsp,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x7990a
movq %rsi, 0xf0(%rsp)
movq %r12, %rdi
leaq 0x190(%rsp), %rsi
leaq 0x430(%rsp), %rdx
movq 0xf8(%rsp), %rcx
movq 0x80(%rsp), %r8
leaq 0x70(%rsp), %r9
callq 0x670f6
testq %rax, %rax
movq %rbx, 0x88(%rsp)
jne 0x79af7
movups 0x39b71(%rip), %xmm0 # 0xb3553
movaps %xmm0, 0x230(%rsp)
movabsq $0x203a6e6f696765, %rax # imm = 0x203A6E6F696765
movq %rax, 0x23f(%rsp)
movq (%r13), %rax
movq 0x20(%rsp), %rcx
leaq (%rax,%rcx), %rsi
addq $0x1f0, %rsi # imm = 0x1F0
leaq 0x246(%rsp), %rdi
callq 0x3250
leaq 0x230(%rsp), %rbx
movq %rbx, %rdi
callq 0x30f0
cltq
leaq (%rsp,%rax), %rdi
addq $0x230, %rdi # imm = 0x230
movq 0x190(%rsp), %rdx
movq 0x430(%rsp), %rcx
leaq 0x39b19(%rip), %rsi # 0xb356a
xorl %eax, %eax
callq 0x30a0
movq %rbx, %rdi
callq 0x30f0
movq %rax, %r15
movq %r12, %rdi
callq 0x65319
cmpq $0x2, %rax
jl 0x79ac7
movl $0x1, %ebx
leaq 0x230(%rsp), %rbp
movslq %r15d, %rax
leaq (%rsp,%rax), %rdi
addq $0x230, %rdi # imm = 0x230
movq 0x190(%rsp,%rbx,8), %rdx
movq 0x430(%rsp,%rbx,8), %rcx
leaq 0x39ad2(%rip), %rsi # 0xb3575
xorl %eax, %eax
callq 0x30a0
movq %rbp, %rdi
callq 0x30f0
movq %rax, %r15
incq %rbx
movq %r12, %rdi
callq 0x65319
cmpq %rbx, %rax
jg 0x79a7e
jmp 0x79acf
leaq 0x230(%rsp), %rbp
movslq %r15d, %rax
movw $0x5d, 0x230(%rsp,%rax)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x18f07
movq 0xe8(%rsp), %r15
movq 0x88(%rsp), %rbx
cmpq $0x0, 0x70(%rsp)
jle 0x7a644
xorl %ecx, %ecx
xorq $0x1, %rbx
movq 0x80(%rsp), %rax
movq %rcx, 0x120(%rsp)
movq (%rax,%rcx,8), %rsi
movq %r12, %rdi
movq %rsi, 0x10(%rsp)
leaq 0x470(%rsp), %rdx
leaq 0x370(%rsp), %rcx
callq 0x5f51f
movq 0x70(%rsp), %rax
xorq $0x1, %rax
orq %rbx, %rax
sete %al
xorl %ecx, %ecx
movq 0x670(%rsp,%rcx,8), %rsi
testq %rsi, %rsi
je 0x79b7b
addq 0x370(%rsp,%rcx,8), %rsi
movq $0x0, 0x1f0(%rsp,%rcx,8)
subq 0x470(%rsp,%rcx,8), %rsi
xorl %edx, %edx
jmp 0x79c41
cmpq %rcx, %r15
jne 0x79baa
testb %al, %al
je 0x79bcf
movq 0x370(%rsp,%rcx,8), %rsi
subq 0x470(%rsp,%rcx,8), %rsi
leaq 0x1(%rsi), %rdx
movq %rdx, 0x1f0(%rsp,%rcx,8)
addq 0x4b0(%rsp,%rcx,8), %rsi
jmp 0x79b74
movq 0x4b0(%rsp,%rcx,8), %rdx
movq %rdx, 0x1f0(%rsp,%rcx,8)
movq 0x370(%rsp,%rcx,8), %rsi
addq %rdx, %rsi
subq 0x470(%rsp,%rcx,8), %rsi
jmp 0x79c41
movq 0x470(%rsp,%rcx,8), %r8
movq 0x190(%rsp,%rcx,8), %rdi
cmpq %rdi, %r8
jge 0x79be8
xorl %edx, %edx
jmp 0x79bf6
movq %r8, %rdx
subq 0x3f0(%rsp,%rcx,8), %rdx
movq %r8, %rdi
testq %rdx, %rdx
jns 0x79c03
addq 0x330(%rsp,%rcx,8), %rdx
subq 0x370(%rsp,%rcx,8), %rdi
movq 0x330(%rsp,%rcx,8), %rsi
cmpq %rsi, %rdx
movl $0x0, %r9d
cmovgeq %rsi, %r9
subq %r9, %rdx
movq 0x370(%rsp,%rcx,8), %rsi
subq %r8, %rsi
addq 0x4b0(%rsp,%rcx,8), %rsi
addq %rsi, %rdi
movq %rdi, 0x1f0(%rsp,%rcx,8)
movq %rsi, 0x4f0(%rsp,%rcx,8)
movq %rdx, 0x5f0(%rsp,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x79b4b
movq (%r13), %r12
movq 0x20(%rsp), %rax
leaq (%r12,%rax), %rbx
movswq (%r12,%rax), %r13
movl 0x224(%r12,%rax), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x7c(%rsp)
cmpl $0x3, %ecx
movq %rax, 0x108(%rsp)
jae 0x79d56
movq 0xd8(%rsp), %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x30(%rsp)
movl %r13d, %esi
cmpw $0x2, %r13w
jl 0x79cec
movl 0x30(%rsp), %edx
movq 0x68(%rsp), %rax
leaq (%r12,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x18(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x34(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x79cc7
testw %r13w, %r13w
jle 0x79ff3
movq 0xd0(%rsp), %rax
addq %r12, %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
movslq 0x30(%rsp,%rcx), %rdx
movq (%rax,%rcx,2), %rdi
movq %rdi, %r8
imulq %rdx, %r8
incq %r8
movq %r8, 0x230(%rsp,%rcx,2)
incq %rdx
imulq %rdi, %rdx
movq %rdx, 0x90(%rsp,%rcx,2)
movq -0x1f8(%rax,%rcx,2), %rdi
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
movq %rdx, 0x90(%rsp,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x79d07
jmp 0x79ff3
cmpl $0x4, %eax
je 0x79db0
testl %eax, %eax
jne 0x79ff3
movq 0x2a8(%rbx), %rax
testq %rax, %rax
je 0x79e86
movq 0x18(%rsp), %rdi
cmpq %rax, %rdi
jge 0x79fbe
testw %r13w, %r13w
jle 0x79f3e
movq 0x60(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r13
jne 0x79d9b
jmp 0x79f43
movq 0xd8(%rsp), %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x30(%rsp)
movl %r13d, %esi
cmpw $0x2, %r13w
jl 0x79e0d
movl 0x30(%rsp), %edx
movq 0x68(%rsp), %rax
leaq (%r12,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x18(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x34(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x79de8
testw %r13w, %r13w
jle 0x79ff3
movq 0x20(%rsp), %rax
movq 0x1e8(%r12,%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x30(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x230(%rsp,%rcx,2)
movq 0x260(%rbx,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x79e64
movq 0x1e8(%rbx), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x79e69
movq 0x30(%rbx,%rcx,2), %rdi
movq %rdi, 0x90(%rsp,%rcx,2)
addl 0x260(%rbx,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x79e2c
jmp 0x79ff3
testw %r13w, %r13w
movq 0x18(%rsp), %rdi
jle 0x79eb3
movq 0x60(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r13
jne 0x79ea1
jmp 0x79eb8
movl $0x1, %eax
testq %rdi, %rdi
js 0x79fbe
cmpq %rax, %rdi
jge 0x79fbe
testw %r13w, %r13w
jle 0x79ff3
movq 0x1e8(%rbx), %rcx
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rsi
xorl %edi, %edi
movq 0x18(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%rdi,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%r8,8), %r11
movq %r11, 0x230(%rsp,%rdi,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x79f1e
movq 0xd4e70(%rsi,%rdi,8), %rdx
jmp 0x79f26
movq 0x8(%r10,%r8,8), %rdx
decq %rdx
addq %r9, %r8
movq %rdx, 0x90(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %r13
jne 0x79eee
jmp 0x79ff3
movl $0x1, %eax
testq %rdi, %rdi
js 0x79fbe
cmpq %rax, %rdi
jge 0x79fbe
testw %r13w, %r13w
jle 0x79ff3
movq 0x1e8(%rbx), %rcx
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rsi
xorl %edi, %edi
movq 0x18(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%rdi,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%r8,8), %r11
movq %r11, 0x230(%rsp,%rdi,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x79fa1
movq 0xd4e70(%rsi,%rdi,8), %rdx
jmp 0x79fa9
movq 0x8(%r10,%r8,8), %rdx
decq %rdx
addq %r9, %r8
movq %rdx, 0x90(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %r13
jne 0x79f71
jmp 0x79ff3
testw %r13w, %r13w
jle 0x79ff3
leaq (,%r13,8), %rbp
leaq 0x230(%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3170
leaq 0x90(%rsp), %rdi
movl $0xff, %esi
movq %rbp, %rdx
callq 0x3170
movq %r13, %r15
decq %r15
jne 0x7a027
movq 0x90(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0xc0(%r12,%rcx), %rcx
subq 0x230(%rsp), %rax
leaq (%rax,%rcx,2), %rax
incq %rax
movq %rax, 0x5b0(%rsp)
cmpw $0x2, %r13w
movq 0x10(%rsp), %r8
jl 0x7a088
movq 0xe0(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %ebp
xorl %edx, %edx
xorl %eax, %eax
movq 0x5f0(%rsp,%rdx,8), %rsi
imulq %rbp, %rsi
addq %rsi, %rax
movq 0x90(%rsp,%rdx,8), %rsi
movq (%rcx,%rdx,8), %rdi
subq 0x230(%rsp,%rdx,8), %rsi
leaq (%rsi,%rdi,2), %rsi
incq %rsi
movq %rsi, 0x5b0(%rsp,%rdx,8)
imulq %rsi, %rbp
incq %rdx
cmpq %rdx, %r15
jne 0x7a048
jmp 0x7a08f
movl $0x1, %ebp
xorl %eax, %eax
imulq 0x5e8(%rsp,%r13,8), %rbp
addq %rax, %rbp
movq 0x1e0(%rbx), %rcx
movslq 0x18(%rbx), %rax
movq %rax, 0x110(%rsp)
imulq %rax, %rbp
movq 0x18(%rsp), %rax
movq %rcx, 0x118(%rsp)
addq (%rcx,%rax,8), %rbp
cmpl $0x3, 0x7c(%rsp)
jae 0x7a190
movslq %r8d, %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x30(%rsp)
movl %r13d, %esi
cmpw $0x2, %r13w
jl 0x7a126
movl 0x30(%rsp), %edx
movq 0x68(%rsp), %rax
leaq (%r12,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x34(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x7a101
testw %r13w, %r13w
jle 0x7a468
movq 0xd0(%rsp), %rax
addq %r12, %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
movslq 0x30(%rsp,%rcx), %rdx
movq (%rax,%rcx,2), %rdi
movq %rdi, %r8
imulq %rdx, %r8
incq %r8
movq %r8, 0x230(%rsp,%rcx,2)
incq %rdx
imulq %rdi, %rdx
movq %rdx, 0x90(%rsp,%rcx,2)
movq -0x1f8(%rax,%rcx,2), %rdi
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
movq %rdx, 0x90(%rsp,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x7a141
jmp 0x7a468
movq 0x108(%rsp), %rax
cmpl $0x4, %eax
je 0x7a1f2
testl %eax, %eax
jne 0x7a468
movq 0x2a8(%rbx), %rax
testq %rax, %rax
je 0x7a2c3
movq 0x10(%rsp), %rdi
cmpq %rax, %rdi
jge 0x7a2f0
testw %r13w, %r13w
jle 0x7a3b4
movq 0x60(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r13
jne 0x7a1dd
jmp 0x7a3b9
movslq %r8d, %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x30(%rsp)
movl %r13d, %esi
cmpw $0x2, %r13w
jl 0x7a24a
movl 0x30(%rsp), %edx
movq 0x68(%rsp), %rax
leaq (%r12,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x34(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x7a225
testw %r13w, %r13w
jle 0x7a468
movq 0x20(%rsp), %rax
movq 0x1e8(%r12,%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x30(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x230(%rsp,%rcx,2)
movq 0x260(%rbx,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x7a2a1
movq 0x1e8(%rbx), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x7a2a6
movq 0x30(%rbx,%rcx,2), %rdi
movq %rdi, 0x90(%rsp,%rcx,2)
addl 0x260(%rbx,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x7a269
jmp 0x7a468
testw %r13w, %r13w
movq 0x10(%rsp), %rdi
jle 0x7a329
movq 0x60(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r13
jne 0x7a2de
jmp 0x7a32e
testw %r13w, %r13w
jle 0x7a468
movzwl %r13w, %edx
shll $0x3, %edx
leaq 0x230(%rsp), %rdi
xorl %esi, %esi
callq 0x3170
movq %r13, %rdx
shlq $0x3, %rdx
leaq 0x90(%rsp), %rdi
movl $0xff, %esi
jmp 0x7a463
movl $0x1, %eax
testq %rdi, %rdi
js 0x7a434
cmpq %rax, %rdi
jge 0x7a434
testw %r13w, %r13w
jle 0x7a468
movq 0x1e8(%rbx), %rcx
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x230(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x7a394
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x7a39c
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
addq %r9, %rdi
movq %rdx, 0x90(%rsp,%r8,8)
incq %r8
cmpq %r8, %r13
jne 0x7a364
jmp 0x7a468
movl $0x1, %eax
testq %rdi, %rdi
js 0x7a434
cmpq %rax, %rdi
jge 0x7a434
testw %r13w, %r13w
jle 0x7a468
movq 0x1e8(%rbx), %rcx
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x230(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x7a417
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x7a41f
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
addq %r9, %rdi
movq %rdx, 0x90(%rsp,%r8,8)
incq %r8
cmpq %r8, %r13
jne 0x7a3e7
jmp 0x7a468
testw %r13w, %r13w
jle 0x7a468
movq %r13, %rbx
shlq $0x3, %rbx
leaq 0x230(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3170
leaq 0x90(%rsp), %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x3170
testq %r15, %r15
jne 0x7a499
movq 0x90(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0xc0(%r12,%rcx), %rcx
subq 0x230(%rsp), %rax
leaq (%rax,%rcx,2), %rax
incq %rax
movq %rax, 0x570(%rsp)
cmpw $0x2, %r13w
movq 0x88(%rsp), %rbx
jl 0x7a4fe
addq 0xe0(%rsp), %r12
movl $0x1, %edi
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x10(%rsp), %r9
movq 0x1f0(%rsp,%rcx,8), %rdx
imulq %rdi, %rdx
addq %rdx, %rax
movq 0x90(%rsp,%rcx,8), %rdx
movq (%r12,%rcx,8), %rsi
subq 0x230(%rsp,%rcx,8), %rdx
leaq (%rdx,%rsi,2), %rdx
incq %rdx
movq %rdx, 0x570(%rsp,%rcx,8)
imulq %rdx, %rdi
incq %rcx
cmpq %rcx, %r15
jne 0x7a4be
jmp 0x7a50a
movl $0x1, %edi
xorl %eax, %eax
movq 0x10(%rsp), %r9
imulq 0x1e8(%rsp,%r13,8), %rdi
addq %rax, %rdi
imulq 0x110(%rsp), %rdi
movq 0x118(%rsp), %rax
addq (%rax,%r9,8), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x170(%rsp)
movl %eax, 0x150(%rsp)
cmpw $0x1, %r14w
movq 0x140(%rsp), %r8
je 0x7a594
movl 0x170(%rsp), %eax
movl 0x150(%rsp), %ecx
xorl %edx, %edx
imull 0x570(%rsp,%rdx,8), %ecx
movl %ecx, 0x150(%rsp,%rdx,4)
imull 0x5b0(%rsp,%rdx,8), %eax
movl %eax, 0x170(%rsp,%rdx,4)
movl %ecx, 0x154(%rsp,%rdx,4)
movl %eax, 0x174(%rsp,%rdx,4)
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq %rsi, %r8
jne 0x7a55c
xorl %eax, %eax
movq 0x148(%rsp), %r12
leaq 0x62313(%rip), %r13 # 0xdc8b8
movq 0xe8(%rsp), %r15
movl 0x4f0(%rsp,%rax,8), %ecx
subl 0x1f0(%rsp,%rax,8), %ecx
incl %ecx
movl %ecx, 0x1d0(%rsp,%rax,4)
incq %rax
cmpq %rax, %r14
jne 0x7a5ad
movl 0x1d0(%rsp), %eax
imull 0x2c(%rsp), %eax
movl %eax, 0x1d0(%rsp)
movq 0x128(%rsp), %rcx
testl %ecx, %ecx
js 0x7a602
leaq 0x6231e(%rip), %rax # 0xdc910
movq (%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movq 0x18(%rax,%rcx,8), %rax
movl (%rax,%r9,4), %r9d
movl %r9d, (%rsp)
leaq 0x150(%rsp), %rsi
movq %rbp, %rdx
leaq 0x170(%rsp), %rcx
leaq 0x1d0(%rsp), %r8
movq 0x138(%rsp), %r9
callq 0x58f8e
movq 0x120(%rsp), %rcx
incq %rcx
cmpq 0x70(%rsp), %rcx
jl 0x79b05
movq 0xf0(%rsp), %rsi
incq %rsi
cmpq %rbx, %rsi
movq 0x100(%rsp), %rdi
jne 0x79908
xorl %eax, %eax
cmpq %rax, %r15
jne 0x7a6a6
movq 0x530(%rsp,%rax,8), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x3f0(%rsp,%rax,8)
leaq (%rcx,%rdi), %rsi
movq %rsi, 0x3b0(%rsp,%rax,8)
movq 0x330(%rsp,%rax,8), %rdx
movl $0x1, %ebx
cmpq %rdx, %rsi
jle 0x7a6c6
xorl %ebx, %ebx
cmpq %rdx, %rcx
setl %bl
incq %rbx
jmp 0x7a6c6
movq 0x630(%rsp,%rax,8), %rcx
movq %rcx, 0x3f0(%rsp,%rax,8)
movq 0x530(%rsp,%rax,8), %rcx
movq %rcx, 0x3b0(%rsp,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x7a662
testq %rbx, %rbx
jle 0x7b47c
xorl %esi, %esi
xorl %eax, %eax
movq %rbx, %rcx
xorq $0x2, %rcx
movq %r15, %rdx
xorq %rax, %rdx
orq %rcx, %rdx
jne 0x7a710
testq %rsi, %rsi
je 0x7a752
movq $0x1, 0x190(%rsp,%rax,8)
movq 0x3b0(%rsp,%rax,8), %rcx
subq 0x330(%rsp,%rax,8), %rcx
jmp 0x7a77c
cmpq %rax, %r15
jne 0x7a738
movq 0x3b0(%rsp,%rax,8), %rcx
cmpq 0x330(%rsp,%rax,8), %rcx
jle 0x7a76c
movq $0x1, 0x190(%rsp,%rax,8)
movq %rdi, %rcx
jmp 0x7a77c
movq 0x3f0(%rsp,%rax,8), %rcx
movq %rcx, 0x190(%rsp,%rax,8)
movq 0x3b0(%rsp,%rax,8), %rcx
jmp 0x7a77c
movq 0x3f0(%rsp,%rax,8), %rcx
movq %rcx, 0x190(%rsp,%rax,8)
movq 0x330(%rsp,%rax,8), %rcx
jmp 0x7a77c
movq 0x3f0(%rsp,%rax,8), %rdx
movq %rdx, 0x190(%rsp,%rax,8)
movq %rcx, 0x430(%rsp,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x7a6db
movq %rsi, 0xf0(%rsp)
movq %r12, %rdi
leaq 0x190(%rsp), %rsi
leaq 0x430(%rsp), %rdx
movq 0xf8(%rsp), %rcx
movq 0x80(%rsp), %r8
leaq 0x70(%rsp), %r9
callq 0x670f6
testq %rax, %rax
movq %rbx, 0x88(%rsp)
jne 0x7a8f2
movups 0x38d76(%rip), %xmm0 # 0xb3553
movaps %xmm0, 0x230(%rsp)
movabsq $0x203a6e6f696765, %rax # imm = 0x203A6E6F696765
movq %rax, 0x23f(%rsp)
movq (%r13), %rax
movq 0x20(%rsp), %rcx
leaq (%rax,%rcx), %rsi
addq $0x1f0, %rsi # imm = 0x1F0
leaq 0x246(%rsp), %rdi
callq 0x3250
leaq 0x230(%rsp), %rbx
movq %rbx, %rdi
callq 0x30f0
cltq
leaq (%rsp,%rax), %rdi
addq $0x230, %rdi # imm = 0x230
movq 0x190(%rsp), %rdx
movq 0x430(%rsp), %rcx
leaq 0x38d1e(%rip), %rsi # 0xb356a
xorl %eax, %eax
callq 0x30a0
movq %rbx, %rdi
callq 0x30f0
movq %rax, %r15
movq %r12, %rdi
callq 0x65319
cmpq $0x2, %rax
jl 0x7a8c2
movl $0x1, %ebx
leaq 0x230(%rsp), %rbp
movslq %r15d, %rax
leaq (%rsp,%rax), %rdi
addq $0x230, %rdi # imm = 0x230
movq 0x190(%rsp,%rbx,8), %rdx
movq 0x430(%rsp,%rbx,8), %rcx
leaq 0x38cd7(%rip), %rsi # 0xb3575
xorl %eax, %eax
callq 0x30a0
movq %rbp, %rdi
callq 0x30f0
movq %rax, %r15
incq %rbx
movq %r12, %rdi
callq 0x65319
cmpq %rbx, %rax
jg 0x7a879
jmp 0x7a8ca
leaq 0x230(%rsp), %rbp
movslq %r15d, %rax
movw $0x5d, 0x230(%rsp,%rax)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x18f07
movq 0xe8(%rsp), %r15
movq 0x88(%rsp), %rbx
cmpq $0x0, 0x70(%rsp)
jle 0x7b460
xorl %ecx, %ecx
xorq $0x1, %rbx
movq 0x80(%rsp), %rax
movq %rcx, 0x120(%rsp)
movq (%rax,%rcx,8), %rsi
movq %r12, %rdi
movq %rsi, 0x10(%rsp)
leaq 0x470(%rsp), %rdx
leaq 0x370(%rsp), %rcx
callq 0x5f51f
movq 0x70(%rsp), %rax
xorq $0x1, %rax
orq %rbx, %rax
sete %al
xorl %ecx, %ecx
movq 0x670(%rsp,%rcx,8), %rdx
testq %rdx, %rdx
je 0x7a97e
movq $0x0, 0x1f0(%rsp,%rcx,8)
addq 0x370(%rsp,%rcx,8), %rdx
subq 0x470(%rsp,%rcx,8), %rdx
movq %rdx, 0x4f0(%rsp,%rcx,8)
xorl %edx, %edx
jmp 0x7aa65
cmpq %rcx, %r15
jne 0x7a9bc
testb %al, %al
je 0x7a9e9
movq 0x4b0(%rsp,%rcx,8), %rdx
movq %rdx, 0x1f0(%rsp,%rcx,8)
leaq -0x1(,%rdx,2), %rsi
addq 0x530(%rsp,%rcx,8), %rdx
movq %rsi, 0x4f0(%rsp,%rcx,8)
subq 0x630(%rsp,%rcx,8), %rdx
jmp 0x7aa62
movq 0x4b0(%rsp,%rcx,8), %rdx
movq %rdx, 0x1f0(%rsp,%rcx,8)
movq 0x370(%rsp,%rcx,8), %rsi
addq %rdx, %rsi
subq 0x470(%rsp,%rcx,8), %rsi
movq %rsi, 0x4f0(%rsp,%rcx,8)
jmp 0x7aa65
movq 0x470(%rsp,%rcx,8), %r8
movq 0x530(%rsp,%rcx,8), %rdx
movq %rdx, %rsi
notq %rsi
movq 0x370(%rsp,%rcx,8), %r9
movq 0x430(%rsp,%rcx,8), %rdi
cmpq %rdi, %r9
cmovlq %r9, %rdi
addq %r8, %rsi
jns 0x7aa23
addq 0x330(%rsp,%rcx,8), %rsi
movq 0x330(%rsp,%rcx,8), %r9
cmpq %r9, %rsi
jge 0x7aa33
xorl %r9d, %r9d
subq %r8, %rdi
movq 0x4b0(%rsp,%rcx,8), %r8
movq %r8, 0x1f0(%rsp,%rcx,8)
addq %r8, %rdi
movq %rdi, 0x4f0(%rsp,%rcx,8)
addq %r8, %rdx
addq %rsi, %rdx
addq 0x630(%rsp,%rcx,8), %r9
subq %r9, %rdx
incq %rdx
movq %rdx, 0x5f0(%rsp,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x7a946
movq (%r13), %r12
movq 0x20(%rsp), %rax
leaq (%r12,%rax), %rbx
movswq (%r12,%rax), %r15
movl 0x224(%r12,%rax), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x7c(%rsp)
cmpl $0x3, %ecx
movq %rax, 0x108(%rsp)
jae 0x7ab72
movq 0xd8(%rsp), %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x30(%rsp)
movl %r15d, %esi
cmpw $0x2, %r15w
jl 0x7ab08
movl 0x30(%rsp), %edx
movq 0x68(%rsp), %rax
leaq (%r12,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x18(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x34(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x7aae3
testw %r15w, %r15w
jle 0x7ae0f
movq 0xd0(%rsp), %rax
addq %r12, %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
movslq 0x30(%rsp,%rcx), %rdx
movq (%rax,%rcx,2), %rdi
movq %rdi, %r8
imulq %rdx, %r8
incq %r8
movq %r8, 0x230(%rsp,%rcx,2)
incq %rdx
imulq %rdi, %rdx
movq %rdx, 0x90(%rsp,%rcx,2)
movq -0x1f8(%rax,%rcx,2), %rdi
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
movq %rdx, 0x90(%rsp,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x7ab23
jmp 0x7ae0f
cmpl $0x4, %eax
je 0x7abcc
testl %eax, %eax
jne 0x7ae0f
movq 0x2a8(%rbx), %rax
testq %rax, %rax
je 0x7aca2
movq 0x18(%rsp), %rdi
cmpq %rax, %rdi
jge 0x7adda
testw %r15w, %r15w
jle 0x7ad5a
movq 0x60(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r15
jne 0x7abb7
jmp 0x7ad5f
movq 0xd8(%rsp), %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x30(%rsp)
movl %r15d, %esi
cmpw $0x2, %r15w
jl 0x7ac29
movl 0x30(%rsp), %edx
movq 0x68(%rsp), %rax
leaq (%r12,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x18(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x34(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x7ac04
testw %r15w, %r15w
jle 0x7ae0f
movq 0x20(%rsp), %rax
movq 0x1e8(%r12,%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x30(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x230(%rsp,%rcx,2)
movq 0x260(%rbx,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x7ac80
movq 0x1e8(%rbx), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x7ac85
movq 0x30(%rbx,%rcx,2), %rdi
movq %rdi, 0x90(%rsp,%rcx,2)
addl 0x260(%rbx,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x7ac48
jmp 0x7ae0f
testw %r15w, %r15w
movq 0x18(%rsp), %rdi
jle 0x7accf
movq 0x60(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r15
jne 0x7acbd
jmp 0x7acd4
movl $0x1, %eax
testq %rdi, %rdi
js 0x7adda
cmpq %rax, %rdi
jge 0x7adda
testw %r15w, %r15w
jle 0x7ae0f
movq 0x1e8(%rbx), %rcx
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rsi
xorl %edi, %edi
movq 0x18(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x230(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x7ad3a
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x7ad42
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
addq %r9, %rdi
movq %rdx, 0x90(%rsp,%r8,8)
incq %r8
cmpq %r8, %r15
jne 0x7ad0a
jmp 0x7ae0f
movl $0x1, %eax
testq %rdi, %rdi
js 0x7adda
cmpq %rax, %rdi
jge 0x7adda
testw %r15w, %r15w
jle 0x7ae0f
movq 0x1e8(%rbx), %rcx
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rsi
xorl %edi, %edi
movq 0x18(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x230(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x7adbd
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x7adc5
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
addq %r9, %rdi
movq %rdx, 0x90(%rsp,%r8,8)
incq %r8
cmpq %r8, %r15
jne 0x7ad8d
jmp 0x7ae0f
testw %r15w, %r15w
jle 0x7ae0f
leaq (,%r15,8), %rbp
leaq 0x230(%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3170
leaq 0x90(%rsp), %rdi
movl $0xff, %esi
movq %rbp, %rdx
callq 0x3170
movq %r15, %r13
decq %r13
jne 0x7ae43
movq 0x90(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0xc0(%r12,%rcx), %rcx
subq 0x230(%rsp), %rax
leaq (%rax,%rcx,2), %rax
incq %rax
movq %rax, 0x5b0(%rsp)
cmpw $0x2, %r15w
movq 0x10(%rsp), %r8
jl 0x7aea4
movq 0xe0(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %ebp
xorl %eax, %eax
xorl %edx, %edx
movq 0x5f0(%rsp,%rdx,8), %rsi
imulq %rbp, %rsi
addq %rsi, %rax
movq 0x90(%rsp,%rdx,8), %rsi
movq (%rcx,%rdx,8), %rdi
subq 0x230(%rsp,%rdx,8), %rsi
leaq (%rsi,%rdi,2), %rsi
incq %rsi
movq %rsi, 0x5b0(%rsp,%rdx,8)
imulq %rsi, %rbp
incq %rdx
cmpq %rdx, %r13
jne 0x7ae64
jmp 0x7aeab
movl $0x1, %ebp
xorl %eax, %eax
imulq 0x5e8(%rsp,%r15,8), %rbp
addq %rax, %rbp
movq 0x1e0(%rbx), %rcx
movslq 0x18(%rbx), %rax
movq %rax, 0x110(%rsp)
imulq %rax, %rbp
movq 0x18(%rsp), %rax
movq %rcx, 0x118(%rsp)
addq (%rcx,%rax,8), %rbp
cmpl $0x3, 0x7c(%rsp)
jae 0x7afac
movslq %r8d, %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x30(%rsp)
movl %r15d, %esi
cmpw $0x2, %r15w
jl 0x7af42
movl 0x30(%rsp), %edx
movq 0x68(%rsp), %rax
leaq (%r12,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x34(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x7af1d
testw %r15w, %r15w
jle 0x7b284
movq 0xd0(%rsp), %rax
addq %r12, %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
movslq 0x30(%rsp,%rcx), %rdx
movq (%rax,%rcx,2), %rdi
movq %rdi, %r8
imulq %rdx, %r8
incq %r8
movq %r8, 0x230(%rsp,%rcx,2)
incq %rdx
imulq %rdi, %rdx
movq %rdx, 0x90(%rsp,%rcx,2)
movq -0x1f8(%rax,%rcx,2), %rdi
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
movq %rdx, 0x90(%rsp,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x7af5d
jmp 0x7b284
movq 0x108(%rsp), %rax
cmpl $0x4, %eax
je 0x7b00e
testl %eax, %eax
jne 0x7b284
movq 0x2a8(%rbx), %rax
testq %rax, %rax
je 0x7b0df
movq 0x10(%rsp), %rdi
cmpq %rax, %rdi
jge 0x7b10c
testw %r15w, %r15w
jle 0x7b1d0
movq 0x60(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r15
jne 0x7aff9
jmp 0x7b1d5
movslq %r8d, %rax
cqto
idivq 0x260(%rbx)
movl %edx, 0x30(%rsp)
movl %r15d, %esi
cmpw $0x2, %r15w
jl 0x7b066
movl 0x30(%rsp), %edx
movq 0x68(%rsp), %rax
leaq (%r12,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x34(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x7b041
testw %r15w, %r15w
jle 0x7b284
movq 0x20(%rsp), %rax
movq 0x1e8(%r12,%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x30(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x230(%rsp,%rcx,2)
movq 0x260(%rbx,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x7b0bd
movq 0x1e8(%rbx), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x7b0c2
movq 0x30(%rbx,%rcx,2), %rdi
movq %rdi, 0x90(%rsp,%rcx,2)
addl 0x260(%rbx,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x7b085
jmp 0x7b284
testw %r15w, %r15w
movq 0x10(%rsp), %rdi
jle 0x7b145
movq 0x60(%rsp), %rax
leaq (%r12,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r15
jne 0x7b0fa
jmp 0x7b14a
testw %r15w, %r15w
jle 0x7b284
movzwl %r15w, %edx
shll $0x3, %edx
leaq 0x230(%rsp), %rdi
xorl %esi, %esi
callq 0x3170
movq %r15, %rdx
shlq $0x3, %rdx
leaq 0x90(%rsp), %rdi
movl $0xff, %esi
jmp 0x7b27f
movl $0x1, %eax
testq %rdi, %rdi
js 0x7b250
cmpq %rax, %rdi
jge 0x7b250
testw %r15w, %r15w
jle 0x7b284
movq 0x1e8(%rbx), %rcx
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x230(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x7b1b0
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x7b1b8
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
addq %r9, %rdi
movq %rdx, 0x90(%rsp,%r8,8)
incq %r8
cmpq %r8, %r15
jne 0x7b180
jmp 0x7b284
movl $0x1, %eax
testq %rdi, %rdi
js 0x7b250
cmpq %rax, %rdi
jge 0x7b250
testw %r15w, %r15w
jle 0x7b284
movq 0x1e8(%rbx), %rcx
movq 0x58(%rsp), %rax
leaq (%r12,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x230(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x7b233
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x7b23b
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
addq %r9, %rdi
movq %rdx, 0x90(%rsp,%r8,8)
incq %r8
cmpq %r8, %r15
jne 0x7b203
jmp 0x7b284
testw %r15w, %r15w
jle 0x7b284
movq %r15, %rbx
shlq $0x3, %rbx
leaq 0x230(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3170
leaq 0x90(%rsp), %rdi
movl $0xff, %esi
movq %rbx, %rdx
callq 0x3170
testq %r13, %r13
jne 0x7b2b5
movq 0x90(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0xc0(%r12,%rcx), %rcx
subq 0x230(%rsp), %rax
leaq (%rax,%rcx,2), %rax
incq %rax
movq %rax, 0x570(%rsp)
cmpw $0x2, %r15w
movq 0x88(%rsp), %rbx
jl 0x7b31a
addq 0xe0(%rsp), %r12
movl $0x1, %edi
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x10(%rsp), %r9
movq 0x1f0(%rsp,%rcx,8), %rdx
imulq %rdi, %rdx
addq %rdx, %rax
movq 0x90(%rsp,%rcx,8), %rdx
movq (%r12,%rcx,8), %rsi
subq 0x230(%rsp,%rcx,8), %rdx
leaq (%rdx,%rsi,2), %rdx
incq %rdx
movq %rdx, 0x570(%rsp,%rcx,8)
imulq %rdx, %rdi
incq %rcx
cmpq %rcx, %r13
jne 0x7b2da
jmp 0x7b326
movl $0x1, %edi
xorl %eax, %eax
movq 0x10(%rsp), %r9
imulq 0x1e8(%rsp,%r15,8), %rdi
addq %rax, %rdi
imulq 0x110(%rsp), %rdi
movq 0x118(%rsp), %rax
addq (%rax,%r9,8), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x170(%rsp)
movl %eax, 0x150(%rsp)
cmpw $0x1, %r14w
movq 0x140(%rsp), %r8
je 0x7b3b0
movl 0x170(%rsp), %eax
movl 0x150(%rsp), %ecx
xorl %edx, %edx
imull 0x570(%rsp,%rdx,8), %ecx
movl %ecx, 0x150(%rsp,%rdx,4)
imull 0x5b0(%rsp,%rdx,8), %eax
movl %eax, 0x170(%rsp,%rdx,4)
movl %ecx, 0x154(%rsp,%rdx,4)
movl %eax, 0x174(%rsp,%rdx,4)
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq %rsi, %r8
jne 0x7b378
xorl %eax, %eax
movq 0x148(%rsp), %r12
leaq 0x614f7(%rip), %r13 # 0xdc8b8
movq 0xe8(%rsp), %r15
movl 0x4f0(%rsp,%rax,8), %ecx
subl 0x1f0(%rsp,%rax,8), %ecx
incl %ecx
movl %ecx, 0x1d0(%rsp,%rax,4)
incq %rax
cmpq %rax, %r14
jne 0x7b3c9
movl 0x1d0(%rsp), %eax
imull 0x2c(%rsp), %eax
movl %eax, 0x1d0(%rsp)
movq 0x128(%rsp), %rcx
testl %ecx, %ecx
js 0x7b41e
leaq 0x61502(%rip), %rax # 0xdc910
movq (%rax), %rax
leaq (%rcx,%rcx,4), %rcx
movq 0x18(%rax,%rcx,8), %rax
movl (%rax,%r9,4), %r9d
movl %r9d, (%rsp)
leaq 0x150(%rsp), %rsi
movq %rbp, %rdx
leaq 0x170(%rsp), %rcx
leaq 0x1d0(%rsp), %r8
movl 0x134(%rsp), %r9d
callq 0x58f8e
movq 0x120(%rsp), %rcx
incq %rcx
cmpq 0x70(%rsp), %rcx
jl 0x7a900
movq 0xf0(%rsp), %rsi
incq %rsi
cmpq %rbx, %rsi
movq 0x100(%rsp), %rdi
jne 0x7a6d9
cmpq 0x138(%rsp), %r15
jge 0x7b49b
movq 0x128(%rsp), %rdi
callq 0x6979c
movq 0x100(%rsp), %rdi
cmpl $0x0, 0x130(%rsp)
je 0x7b4b0
addq %rdi, %rdi
movq %rdi, 0x670(%rsp,%r15,8)
incq %r15
cmpq %r14, %r15
jne 0x79875
movq 0xf8(%rsp), %rdi
callq 0x3330
movq 0x80(%rsp), %rdi
callq 0x3330
addq $0x6a8, %rsp # imm = 0x6A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/ghosts.c |
gai_check_ghost_distr | static logical gai_check_ghost_distr(Integer g_a)
{
Integer handle=GA_OFFSET + g_a;
Integer idx, ndim, np, ipx;
ndim = GA[handle].ndim;
ipx = 0;
for (idx = 0; idx < ndim; idx++) {
for (np = 0; np < GA[handle].nblock[idx]; np++) {
if (np < GA[handle].nblock[idx] - 1) {
if (GA[handle].mapc[ipx+1]-GA[handle].mapc[ipx]+1
<GA[handle].width[idx]) {
return FALSE;
}
} else {
if (GA[handle].dims[idx]-GA[handle].mapc[ipx]+1
<GA[handle].width[idx]) {
return FALSE;
}
}
ipx++;
}
}
return TRUE;
} | pushq %r14
pushq %rbx
leaq 0x6037a(%rip), %rax # 0xdc8b8
movq (%rax), %rcx
imulq $0x368, %rdi, %rsi # imm = 0x368
movswq 0xd4e40(%rcx,%rsi), %rdx
movl $0x1, %eax
testq %rdx, %rdx
jle 0x7c5df
addq %rsi, %rcx
xorl %edi, %edi
xorl %esi, %esi
movslq 0xd4ee0(%rcx,%rsi,4), %r8
testq %r8, %r8
jle 0x7c5d3
leal -0x1(%r8), %r9d
movslq %r9d, %r10
leaq (%rdi,%r8), %r9
xorl %r11d, %r11d
cmpq %r10, %r11
jge 0x7c5a5
movq 0xd5028(%rcx), %rbx
movq 0x8(%rbx,%rdi,8), %r14
subq (%rbx,%rdi,8), %r14
incq %r14
cmpq 0xd4f00(%rcx,%rsi,8), %r14
jge 0x7c5c5
jmp 0x7c5dd
movq 0xd4e70(%rcx,%rsi,8), %rbx
movq 0xd5028(%rcx), %r14
subq (%r14,%rdi,8), %rbx
incq %rbx
cmpq 0xd4f00(%rcx,%rsi,8), %rbx
jl 0x7c5dd
incq %rdi
incq %r11
cmpq %r11, %r8
jne 0x7c581
movq %r9, %rdi
incq %rsi
cmpq %rdx, %rsi
jne 0x7c566
jmp 0x7c5df
xorl %eax, %eax
popq %rbx
popq %r14
retq
| /GlobalArrays[P]ga/global/src/ghosts.c |
pnga_update44_ghosts | logical pnga_update44_ghosts(Integer g_a)
{
Integer idx, idir, i, np, handle=GA_OFFSET + g_a;
Integer size, buflen, buftot, bufsize, ndim, increment[MAXDIM];
Integer proc_rem_snd, proc_rem_rcv, pmax;
Integer msgcnt, length;
Integer width[MAXDIM], dims[MAXDIM], index[MAXDIM];
Integer lo_loc[MAXDIM], hi_loc[MAXDIM];
Integer plo_snd[MAXDIM], phi_snd[MAXDIM];
Integer lo_rcv[MAXDIM], hi_rcv[MAXDIM];
Integer slo_rcv[MAXDIM], shi_rcv[MAXDIM];
Integer plo_rcv[MAXDIM], phi_rcv[MAXDIM];
Integer ld_loc[MAXDIM];
int msglen;
int stride_snd[MAXDIM], stride_rcv[MAXDIM],count[MAXDIM];
char *ptr_snd, *ptr_rcv;
char send_name[32], rcv_name[32];
void *snd_ptr, *rcv_ptr, *snd_ptr_orig, *rcv_ptr_orig;
Integer me = pnga_nodeid();
Integer p_handle;
Integer *_ga_map = NULL;
Integer *_ga_proclist = NULL;
/* This routine makes use of the shift algorithm to update data in the
* ghost cells bounding the local block of visible data. The shift
* algorithm starts by updating the blocks of data along the first
* dimension by grabbing a block of data that is width[0] deep but
* otherwise matches the dimensions of the data residing on the
* calling processor. The update of the second dimension, however,
* grabs a block that is width[1] deep in the second dimension but is
* ldim0 + 2*width[0] in the first dimensions where ldim0 is the
* size of the visible data along the first dimension. The remaining
* dimensions are left the same. For the next update, the width of the
* second dimension is also increased by 2*width[1] and so on. This
* algorith makes use of the fact that data for the dimensions that
* have already been updated is available on each processor and can be
* used in the updates of subsequent dimensions. The total number of
* separate updates is 2*ndim, an update in the negative and positive
* directions for each dimension.
*
* This implementation make use of explicit message passing to perform
* the update. Separate message types for the updates in each coordinate
* direction are used to maintain synchronization locally and to
* guarantee that the data is present before the updates in a new
* coordinate direction take place.
*
* To perform the update, this routine makes use of several copies of
* indices marking the upper and lower limits of data. Indices
* beginning with the character "p" are relative indices marking the
* location of the data set relative to the origin the local patch of
* the global array, all other indices are in absolute coordinates and
* mark locations in the total global array. The indices used by this
* routine are described below.
*
* lo_loc[], hi_loc[]: The lower and upper indices of the visible
* block of data held by the calling processor.
*
* lo_rcv[], hi_rcv[]: The lower and upper indices of the blocks
* of data that will be either sent to or received from a remote
* processor. These indices are NOT corrected for wrap-around
* (periodic) boundary conditions so they can be negative or greater
* than the array dimension values held in dims[].
*
* slo_rcv[], shi_rcv[]: Similar to lo_rcv[] and hi_rcv[], except
* that these indices have been corrected for wrap-around
* boundary conditions.
*
* plo_rcv[], phi_rcv[]: The local indices of the local data patch
* that receive that message from the remote processor.
*
* plo_snd[], phi_snd[]: The local indices of the data patch
* that will be sent to the remote processor. Note that the
* dimensions of the patches represented by plo_rec[], plo_rec[] and
* plo_snd[], phi_snd[] must be the same.
*/
/* if global array has no ghost cells, just return */
if (!pnga_has_ghosts(g_a)) return TRUE;
size = GA[handle].elemsize;
ndim = GA[handle].ndim;
p_handle = GA[handle].p_handle;
/* initialize range increments and get array dimensions */
for (idx=0; idx < ndim; idx++) {
increment[idx] = 0;
width[idx] = (Integer)GA[handle].width[idx];
dims[idx] = (Integer)GA[handle].dims[idx];
}
/* Check to make sure that global array is well-behaved (all processors
have data and the width of the data in each dimension is greater
than the corresponding value in width[]. */
if (!gai_check_ghost_distr(g_a)) return FALSE;
_ga_map = malloc((GAnproc*2*MAXDIM+1)*sizeof(Integer));
if(!_ga_map) pnga_error("pnga_update44_ghosts:malloc failed (_ga_map)",0);
_ga_proclist = malloc(GAnproc*sizeof(Integer));
if(!_ga_proclist) pnga_error("pnga_update44_ghosts:malloc failed (_ga_proclist)",0);
msgcnt = 0;
/* obtain range of data that is held by local processor */
pnga_distribution(g_a,me,lo_loc,hi_loc);
/* Get indices of processor in virtual grid */
pnga_proc_topology(g_a, me, index);
/* Try to find maximum size of message that will be sent during
* update operations and use this to allocate memory for message
* passing buffers. */
buftot = 1;
for (i=0; i<ndim; i++) {
buftot *= (hi_loc[i]-lo_loc[i] + 1 + 2*width[i]);
}
buflen = 1;
for (i = 0; i < ndim; i++) {
idir = hi_loc[i] - lo_loc[i] + 1;
if (buflen < (buftot/(idir + 2*width[i]))*width[i]) {
buflen = (buftot/(idir + 2*width[i]))*width[i];
}
}
bufsize = size*buflen;
strcpy(send_name,"send_buffer");
strcpy(rcv_name,"receive_buffer");
snd_ptr_orig = snd_ptr = pnga_malloc(buflen, GA[handle].type, send_name);
rcv_ptr_orig = rcv_ptr = pnga_malloc(buflen, GA[handle].type, rcv_name);
/* loop over dimensions for sequential update using shift algorithm */
for (idx=0; idx < ndim; idx++) {
/* Do not bother with update if nwidth is zero */
if (width[idx] != 0) {
/* Perform update in negative direction. */
get_remote_block_neg(idx, ndim, lo_loc, hi_loc, slo_rcv, shi_rcv,
dims, width);
/* locate processor with this data */
if (!pnga_locate_region(g_a, slo_rcv, shi_rcv, _ga_map,
_ga_proclist, &np)) ga_RegionError(pnga_ndim(g_a),
slo_rcv, shi_rcv, g_a);
proc_rem_snd = _ga_proclist[0];
if (p_handle >= 0) {
proc_rem_snd = PGRP_LIST[p_handle].inv_map_proc_list[proc_rem_snd];
}
/* Find processor from which data will be recieved */
for (i = 0; i < ndim; i++) {
if (i == idx) {
lo_rcv[i] = hi_loc[i] + 1;
hi_rcv[i] = hi_loc[i] + width[i];
} else {
lo_rcv[i] = lo_loc[i];
hi_rcv[i] = hi_loc[i];
}
}
/* Account for boundaries, if necessary. */
for (i=0; i<ndim; i++) {
if (i == idx) {
if (hi_rcv[i] > dims[i]) {
slo_rcv[i] = 1;
shi_rcv[i] = width[i];
} else {
slo_rcv[i] = lo_rcv[i];
shi_rcv[i] = hi_rcv[i];
}
} else {
slo_rcv[i] = lo_rcv[i];
shi_rcv[i] = hi_rcv[i];
}
}
/* locate processor with this data */
if (!pnga_locate_region(g_a, slo_rcv, shi_rcv, _ga_map,
_ga_proclist, &np)) ga_RegionError(pnga_ndim(g_a),
slo_rcv, shi_rcv, g_a);
proc_rem_rcv = _ga_proclist[0];
if (p_handle >= 0) {
proc_rem_rcv = PGRP_LIST[p_handle].inv_map_proc_list[proc_rem_rcv];
}
/* Get actual coordinates of chunk of data that will be sent to
* remote processor as well as coordinates of the array space that
* will receive data from remote processor. */
for (i = 0; i < ndim; i++) {
if (increment[i] == 0) {
if (i == idx) {
plo_snd[i] = width[i];
phi_snd[i] = 2*width[i] - 1;
plo_rcv[i] = hi_loc[i] - lo_loc[i] + width[i] + 1;
phi_rcv[i] = hi_loc[i] - lo_loc[i] + 2*width[i];
} else {
plo_snd[i] = width[i];
phi_snd[i] = hi_loc[i] - lo_loc[i] + width[i];
plo_rcv[i] = width[i];
phi_rcv[i] = hi_loc[i] - lo_loc[i] + width[i];
}
} else {
plo_rcv[i] = 0;
phi_rcv[i] = hi_loc[i] - lo_loc[i] + increment[i];
plo_snd[i] = 0;
phi_snd[i] = hi_loc[i] - lo_loc[i] + increment[i];
}
}
/* Get pointer to local data buffer and remote data
buffer as well as lists of leading dimenstions */
gam_LocationWithGhosts(me, handle, plo_snd, &ptr_snd, ld_loc);
#if GHOST_PRINT
printf("p[%d] 1: plo_snd[0]: %d plo_snd[1]: %d ptr_snd: %d\n",
GAme, plo_snd[0], plo_snd[1], (Integer)ptr_snd);
fflush(stdout);
#endif
gam_LocationWithGhosts(me, handle, plo_rcv, &ptr_rcv, ld_loc);
#if GHOST_PRINT
printf("p[%d] 1: plo_rcv[0]: %d plo_rcv[1]: %d ptr_rcv: %d\n",
GAme, plo_rcv[0], plo_rcv[1], (Integer)ptr_rcv);
fflush(stdout);
#endif
/* Evaluate strides for send and recieve */
gam_setstride(ndim, size, ld_loc, ld_loc, stride_rcv,
stride_snd);
/* Compute the number of elements in each dimension and store
result in count. Scale the first element in count by the
element size. */
gam_ComputeCount(ndim, plo_rcv, phi_rcv, count);
gam_CountElems(ndim, plo_snd, phi_snd, &length);
length *= size;
count[0] *= size;
/* Fill send buffer with data. */
#if GHOST_PRINT
printf("p[%d]b 1: ptr_snd: %d ptr_rcv: %d\n", GAme, (Integer)ptr_snd,
(Integer)ptr_rcv);
printf("p[%d]b 1: length: %d proc_rem_snd: %d proc_rem_rcv: %d\n",
GAme, (int)length, (int)proc_rem_snd, (int)proc_rem_rcv);
printf("p[%d]b 1: count[0]: %d stride_rcv[0]: %d stride_rcv[1]: %d\n",
GAme, count[0], stride_rcv[0],stride_rcv[1]);
printf("p[%d]b 1: count[1]: %d stride_rcv[2]: %d stride_rcv[3]: %d\n",
GAme, count[1], stride_rcv[2],stride_rcv[3]);
printf("p[%d]b 1: count[2]: %d stride_snd[0]: %d stride_snd[1]: %d\n",
GAme, count[2], stride_snd[0],stride_snd[1]);
printf("p[%d]b 1: count[3]: %d stride_snd[2]: %d stride_snd[3]: %d\n",
GAme, count[3], stride_snd[2],stride_snd[3]);
printf("p[%d]b 1: snd_ptr: %d rcv_ptr: %d\n", GAme, (Integer)snd_ptr,
(Integer)rcv_ptr);
fflush(stdout);
#endif
armci_write_strided(ptr_snd, (int)ndim-1, stride_snd, count, snd_ptr);
/* Send Messages. If processor has odd index in direction idx, it
* sends message first, if processor has even index it receives
* message first. Then process is reversed. Also need to account
* for whether or not there are an odd number of processors along
* update direction. */
#if GHOST_PRINT
printf("p[%d] 1: msgcnt: %d length: %d bufsize: %d proc_rem_snd: %d proc_rem_rcv: %d\n",
GAme, msgcnt, length, bufsize, (int)proc_rem_snd, (int)proc_rem_rcv);
fflush(stdout);
#endif
snd_ptr = snd_ptr_orig;
rcv_ptr = rcv_ptr_orig;
if (GAme != proc_rem_snd) {
if (GA[handle].nblock[idx]%2 == 0) {
if (index[idx]%2 != 0) {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
} else {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
}
if (index[idx]%2 != 0) {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
} else {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
}
} else {
pmax = GA[handle].nblock[idx] - 1;
if (index[idx]%2 != 0) {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
} else if (index[idx] != pmax) {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
}
if (index[idx]%2 != 0) {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
} else if (index[idx] != 0) {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
}
/* make up for odd processor at end of string */
if (index[idx] == 0) {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
}
if (index[idx] == pmax) {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
}
}
} else {
rcv_ptr = snd_ptr;
}
msgcnt++;
/* copy data back into global array */
armci_read_strided(ptr_rcv, (int)ndim-1, stride_rcv, count, rcv_ptr);
/* Find parameters for message in positive direction. */
get_remote_block_pos(idx, ndim, lo_loc, hi_loc, slo_rcv, shi_rcv,
dims, width);
/* locate processor with this data */
if (!pnga_locate_region(g_a, slo_rcv, shi_rcv, _ga_map,
_ga_proclist, &np)) ga_RegionError(pnga_ndim(g_a),
slo_rcv, shi_rcv, g_a);
proc_rem_snd = _ga_proclist[0];
if (p_handle >= 0) {
proc_rem_snd = PGRP_LIST[p_handle].inv_map_proc_list[proc_rem_snd];
}
/* Find processor from which data will be recieved */
for (i = 0; i < ndim; i++) {
if (i == idx) {
lo_rcv[i] = lo_loc[i] - width[i];
hi_rcv[i] = lo_loc[i] - 1;
} else {
lo_rcv[i] = lo_loc[i];
hi_rcv[i] = hi_loc[i];
}
}
/* Account for boundaries, if necessary. */
for (i=0; i<ndim; i++) {
if (i == idx) {
if (hi_rcv[i] < 1) {
slo_rcv[i] = dims[i] - width[i] + 1;
shi_rcv[i] = dims[i];
} else {
slo_rcv[i] = lo_rcv[i];
shi_rcv[i] = hi_rcv[i];
}
} else {
slo_rcv[i] = lo_rcv[i];
shi_rcv[i] = hi_rcv[i];
}
}
/* locate processor with this data */
if (!pnga_locate_region(g_a, slo_rcv, shi_rcv, _ga_map,
_ga_proclist, &np)) ga_RegionError(pnga_ndim(g_a),
slo_rcv, shi_rcv, g_a);
proc_rem_rcv = _ga_proclist[0];
if (p_handle >= 0) {
proc_rem_rcv = PGRP_LIST[p_handle].inv_map_proc_list[proc_rem_rcv];
}
/* Get actual coordinates of chunk of data that will be sent to
* remote processor as well as coordinates of the array space that
* will receive data from remote processor. */
for (i = 0; i < ndim; i++) {
if (increment[i] == 0) {
if (i == idx) {
plo_snd[i] = hi_loc[i] - lo_loc[i] + 1;
phi_snd[i] = hi_loc[i] - lo_loc[i] + width[i];
plo_rcv[i] = 0;
phi_rcv[i] = width[i] - 1;
} else {
plo_snd[i] = width[i];
phi_snd[i] = hi_loc[i] - lo_loc[i] + width[i];
plo_rcv[i] = width[i];
phi_rcv[i] = hi_loc[i] - lo_loc[i] + width[i];
}
} else {
plo_rcv[i] = 0;
phi_rcv[i] = hi_loc[i] - lo_loc[i] + increment[i];
plo_snd[i] = 0;
phi_snd[i] = hi_loc[i] - lo_loc[i] + increment[i];
}
}
/* Get pointer to local data buffer and remote data
buffer as well as lists of leading dimenstions */
gam_LocationWithGhosts(me, handle, plo_snd, &ptr_snd, ld_loc);
#if GHOST_PRINT
printf("p[%d] 2: plo_snd[0]: %d plo_snd[1]: %d ptr_snd: %d\n",
GAme, plo_snd[0], plo_snd[1], (Integer)ptr_snd);
fflush(stdout);
#endif
gam_LocationWithGhosts(me, handle, plo_rcv, &ptr_rcv, ld_loc);
#if GHOST_PRINT
printf("p[%d] 2: plo_rcv[0]: %d plo_rcv[1]: %d ptr_rcv: %d\n",
GAme, plo_rcv[0], plo_rcv[1], (Integer)ptr_rcv);
fflush(stdout);
#endif
/* Evaluate strides for send and recieve */
gam_setstride(ndim, size, ld_loc, ld_loc, stride_rcv,
stride_snd);
/* Compute the number of elements in each dimension and store
result in count. Scale the first element in count by the
element size. */
gam_ComputeCount(ndim, plo_rcv, phi_rcv, count);
gam_CountElems(ndim, plo_snd, phi_snd, &length);
length *= size;
count[0] *= size;
/* Need to reallocate memory if length > buflen */
/* TO DO */
/* Fill send buffer with data. */
#if GHOST_PRINT
printf("p[%d]b 2: ptr_snd: %d ptr_rcv: %d\n", GAme, (Integer)ptr_snd,
(Integer)ptr_rcv);
printf("p[%d]b 2: length: %d proc_rem_snd: %d proc_rem_rcv: %d\n",
GAme, (int)length, (int)proc_rem_snd, (int)proc_rem_rcv);
printf("p[%d]b 2: count[0]: %d stride_rcv[0]: %d stride_rcv[1]: %d\n",
GAme, count[0], stride_rcv[0],stride_rcv[1]);
printf("p[%d]b 2: count[1]: %d stride_rcv[2]: %d stride_rcv[3]: %d\n",
GAme, count[1], stride_rcv[2],stride_rcv[3]);
printf("p[%d]b 2: count[2]: %d stride_snd[0]: %d stride_snd[1]: %d\n",
GAme, count[2], stride_snd[0],stride_snd[1]);
printf("p[%d]b 2: count[3]: %d stride_snd[2]: %d stride_snd[3]: %d\n",
GAme, count[3], stride_snd[2],stride_snd[3]);
printf("p[%d]b 2: snd_ptr: %d rcv_ptr: %d\n", GAme, (Integer)snd_ptr,
(Integer)rcv_ptr);
fflush(stdout);
#endif
armci_write_strided(ptr_snd, (int)ndim-1, stride_snd, count, snd_ptr);
/* Send Messages. If processor has odd index in direction idx, it
* sends message first, if processor has even index it receives
* message first. Then process is reversed. Also need to account
* for whether or not there are an odd number of processors along
* update direction. */
#if GHOST_PRINT
printf("p[%d] 2: msgcnt: %d length: %d bufsize: %d proc_rem_snd: %d proc_rem_rcv: %d\n",
GAme, msgcnt, length, bufsize, (int)proc_rem_snd, (int)proc_rem_rcv);
fflush(stdout);
#endif
snd_ptr = snd_ptr_orig;
rcv_ptr = rcv_ptr_orig;
if (GAme != proc_rem_rcv) {
if (GA[handle].nblock[idx]%2 == 0) {
if (index[idx]%2 != 0) {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
} else {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
}
if (index[idx]%2 != 0) {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
} else {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
}
} else {
pmax = GA[handle].nblock[idx] - 1;
if (index[idx]%2 != 0) {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
} else if (index[idx] != 0) {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
}
if (index[idx]%2 != 0) {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
} else if (index[idx] != pmax) {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
}
/* make up for odd processor at end of string */
if (index[idx] == pmax) {
armci_msg_snd(msgcnt, snd_ptr, length, proc_rem_snd);
}
if (index[idx] == 0) {
armci_msg_rcv(msgcnt, rcv_ptr, bufsize, &msglen, proc_rem_rcv);
}
}
} else {
rcv_ptr = snd_ptr;
}
/* copy data back into global array */
armci_read_strided(ptr_rcv, (int)ndim-1, stride_rcv, count, rcv_ptr);
msgcnt++;
}
if (GA[handle].corner_flag)
increment[idx] = 2*width[idx];
}
pnga_free(rcv_ptr_orig);
pnga_free(snd_ptr_orig);
free(_ga_map);
free(_ga_proclist);
return TRUE;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6c8, %rsp # imm = 0x6C8
movq %rdi, %rbp
xorl %eax, %eax
callq 0x685c6
movq %rax, %r13
movq %rbp, %rdi
callq 0x652f9
testq %rax, %rax
je 0x82de8
leaq 0x3e8(%rbp), %rax
leaq 0x5bfcc(%rip), %rcx # 0xdc8b8
movq (%rcx), %rbx
imulq $0x368, %rax, %rax # imm = 0x368
movl 0x18(%rbx,%rax), %ecx
movq %rcx, 0xb8(%rsp)
movswq (%rbx,%rax), %r15
movq %rax, 0x30(%rsp)
movslq 0x210(%rbx,%rax), %rax
movq %rax, 0x128(%rsp)
testq %r15, %r15
jle 0x80978
leaq (,%r15,8), %r14
leaq 0x640(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3170
imulq $0x368, %rbp, %r12 # imm = 0x368
leaq (%rbx,%r12), %rsi
addq $0xd4f00, %rsi # imm = 0xD4F00
leaq 0x380(%rsp), %rdi
movq %r14, %rdx
callq 0x3220
leaq (%rbx,%r12), %rsi
addq $0xd4e70, %rsi # imm = 0xD4E70
leaq 0x600(%rsp), %rdi
movq %r14, %rdx
callq 0x3220
movq %rbp, %rdi
callq 0x7c534
testq %rax, %rax
je 0x82def
leaq 0x5c008(%rip), %rbx # 0xdc998
imulq $0x70, (%rbx), %rdi
orq $0x8, %rdi
callq 0x33b0
movq %rax, 0xc8(%rsp)
testq %rax, %rax
jne 0x809b8
leaq 0x3a22a(%rip), %rdi # 0xbabdb
xorl %esi, %esi
callq 0x18f07
movq (%rbx), %rdi
shlq $0x3, %rdi
callq 0x33b0
movq %rax, %rbx
testq %rax, %rax
jne 0x809da
leaq 0x3a235(%rip), %rdi # 0xbac08
xorl %esi, %esi
callq 0x18f07
leaq 0x3c0(%rsp), %rdx
leaq 0x340(%rsp), %rcx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5f51f
leaq 0x400(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5f431
movl $0x1, %ecx
testw %r15w, %r15w
jle 0x80a40
xorl %eax, %eax
movq 0x340(%rsp,%rax,8), %rdx
movq 0x380(%rsp,%rax,8), %rsi
subq 0x3c0(%rsp,%rax,8), %rdx
leaq (%rdx,%rsi,2), %rdx
incq %rdx
imulq %rdx, %rcx
incq %rax
cmpq %rax, %r15
jne 0x80a15
movq %rbx, 0xb0(%rsp)
movq %r13, 0x10(%rsp)
testw %r15w, %r15w
movl $0x1, %r13d
jle 0x80a95
xorl %esi, %esi
movq 0x340(%rsp,%rsi,8), %rax
subq 0x3c0(%rsp,%rsi,8), %rax
movq 0x380(%rsp,%rsi,8), %rdi
leaq (%rax,%rdi,2), %r8
incq %r8
movq %rcx, %rax
cqto
idivq %r8
imulq %rdi, %rax
cmpq %rax, %r13
cmovleq %rax, %r13
incq %rsi
cmpq %rsi, %r15
jne 0x80a5b
movabsq $0x6675625f646e6573, %rax # imm = 0x6675625F646E6573
leaq 0x6a0(%rsp), %rdx
movq %rax, (%rdx)
movl $0x726566, 0x8(%rdx) # imm = 0x726566
movabsq $0x5f65766965636572, %rax # imm = 0x5F65766965636572
leaq 0x680(%rsp), %r14
movq %rax, (%r14)
movabsq $0x7265666675625f, %rax # imm = 0x7265666675625F
movq %rax, 0x7(%r14)
leaq 0x5bddd(%rip), %rbx # 0xdc8b8
movq (%rbx), %rax
movq 0x30(%rsp), %r12
movl 0x4(%rax,%r12), %esi
movq %r13, %rdi
callq 0x5d36c
movq %rax, 0x40(%rsp)
movq (%rbx), %rax
movl 0x4(%rax,%r12), %esi
movq %r13, 0x48(%rsp)
movq %r13, %rdi
movq %r14, %rdx
callq 0x5d36c
movq %rax, 0x38(%rsp)
testw %r15w, %r15w
movq 0xb0(%rsp), %rbx
jle 0x82dbf
movq 0x48(%rsp), %rax
imull 0xb8(%rsp), %eax
movq %rax, 0x48(%rsp)
movslq 0x10(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq -0x1(%r15), %rax
leal -0x1(%r15), %ecx
movl %ecx, 0x6c(%rsp)
cmpq $0x2, %rax
movl $0x1, %ecx
cmovgeq %rax, %rcx
movq %rcx, 0x150(%rsp)
imulq $0x368, %rbp, %rcx # imm = 0x368
leaq 0xd50a8(%rcx), %rax
movq %rax, 0xa0(%rsp)
leaq 0xd5068(%rcx), %rax
movq %rax, 0x110(%rsp)
leaq 0xd4ee0(%rcx), %rax
movq %rax, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
leaq 0xd4f00(%rcx), %rax
movq %rax, 0x118(%rsp)
xorl %r13d, %r13d
movq $0x0, 0x60(%rsp)
movq %rbp, 0x158(%rsp)
cmpq $0x0, 0x380(%rsp,%r13,8)
je 0x82d87
movq %r13, %rdi
movq %r15, %rsi
leaq 0x3c0(%rsp), %rdx
leaq 0x340(%rsp), %rcx
leaq 0x1a0(%rsp), %r14
movq %r14, %r8
leaq 0x200(%rsp), %r12
movq %r12, %r9
leaq 0x380(%rsp), %rax
pushq %rax
leaq 0x608(%rsp), %rax
pushq %rax
callq 0x7e041
addq $0x10, %rsp
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq 0xc8(%rsp), %rcx
movq %rbx, %r8
leaq 0x148(%rsp), %r9
callq 0x670f6
testq %rax, %rax
movq %r13, 0x120(%rsp)
jne 0x80d76
movups 0x32901(%rip), %xmm0 # 0xb3553
movaps %xmm0, 0x240(%rsp)
movabsq $0x203a6e6f696765, %rax # imm = 0x203A6E6F696765
movq %rax, 0x24f(%rsp)
leaq 0x5bc45(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq 0x30(%rsp), %rcx
leaq (%rax,%rcx), %rsi
addq $0x1f0, %rsi # imm = 0x1F0
leaq 0x256(%rsp), %rdi
callq 0x3250
leaq 0x240(%rsp), %rbx
movq %rbx, %rdi
callq 0x30f0
cltq
leaq (%rsp,%rax), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x1a0(%rsp), %rdx
movq 0x200(%rsp), %rcx
leaq 0x328a3(%rip), %rsi # 0xb356a
xorl %eax, %eax
callq 0x30a0
movq %rbx, %rdi
callq 0x30f0
movq %rax, %r14
movq %rbp, %r13
movq %rbp, %rdi
callq 0x65319
cmpq $0x2, %rax
jl 0x80d43
movl $0x1, %ebx
leaq 0x240(%rsp), %r12
leaq 0x32877(%rip), %rbp # 0xb3575
movslq %r14d, %rax
leaq (%rsp,%rax), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x1a0(%rsp,%rbx,8), %rdx
movq 0x200(%rsp,%rbx,8), %rcx
movq %rbp, %rsi
xorl %eax, %eax
callq 0x30a0
movq %r12, %rdi
callq 0x30f0
movq %rax, %r14
incq %rbx
movq %r13, %rdi
callq 0x65319
cmpq %rbx, %rax
jg 0x80cfe
jmp 0x80d4b
leaq 0x240(%rsp), %r12
movslq %r14d, %rax
movw $0x5d, 0x240(%rsp,%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x18f07
movq 0xb0(%rsp), %rbx
movq %r13, %rbp
movq 0x120(%rsp), %r13
movq (%rbx), %rcx
movq 0x128(%rsp), %rax
leaq (%rax,%rax,4), %r14
testl %eax, %eax
js 0x80d9c
leaq 0x5bb80(%rip), %rax # 0xdc910
movq (%rax), %rax
movq 0x18(%rax,%r14,8), %rax
movslq (%rax,%rcx,4), %rcx
movq %rcx, 0x28(%rsp)
xorl %eax, %eax
cmpq %rax, %r13
jne 0x80dc6
movq 0x340(%rsp,%rax,8), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x580(%rsp,%rax,8)
addq 0x380(%rsp,%rax,8), %rcx
jmp 0x80dde
movq 0x3c0(%rsp,%rax,8), %rcx
movq %rcx, 0x580(%rsp,%rax,8)
movq 0x340(%rsp,%rax,8), %rcx
movq %rcx, 0x5c0(%rsp,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x80da3
xorl %eax, %eax
cmpq %rax, %r13
jne 0x80e1d
movq 0x5c0(%rsp,%rax,8), %rcx
cmpq 0x600(%rsp,%rax,8), %rcx
jle 0x80e37
movq $0x1, 0x1a0(%rsp,%rax,8)
movq 0x380(%rsp,%rax,8), %rcx
jmp 0x80e47
movq 0x580(%rsp,%rax,8), %rcx
movq %rcx, 0x1a0(%rsp,%rax,8)
movq 0x5c0(%rsp,%rax,8), %rcx
jmp 0x80e47
movq 0x580(%rsp,%rax,8), %rdx
movq %rdx, 0x1a0(%rsp,%rax,8)
movq %rcx, 0x200(%rsp,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x80df0
movq %rbp, %rdi
leaq 0x1a0(%rsp), %rsi
leaq 0x200(%rsp), %rdx
movq 0xc8(%rsp), %rcx
movq %rbx, %r8
leaq 0x148(%rsp), %r9
callq 0x670f6
testq %rax, %rax
movq %r14, 0x58(%rsp)
jne 0x80fbd
movups 0x326bc(%rip), %xmm0 # 0xb3553
movaps %xmm0, 0x240(%rsp)
movabsq $0x203a6e6f696765, %rax # imm = 0x203A6E6F696765
movq %rax, 0x24f(%rsp)
leaq 0x5ba00(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq 0x30(%rsp), %rcx
leaq (%rax,%rcx), %rsi
addq $0x1f0, %rsi # imm = 0x1F0
leaq 0x256(%rsp), %rdi
callq 0x3250
leaq 0x240(%rsp), %rbx
movq %rbx, %rdi
callq 0x30f0
cltq
leaq (%rsp,%rax), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x1a0(%rsp), %rdx
movq 0x200(%rsp), %rcx
leaq 0x3265e(%rip), %rsi # 0xb356a
xorl %eax, %eax
callq 0x30a0
movq %rbx, %rdi
callq 0x30f0
movq %rax, %r14
movq %rbp, %r13
movq %rbp, %rdi
callq 0x65319
cmpq $0x2, %rax
jl 0x80f88
movl $0x1, %ebx
leaq 0x240(%rsp), %r12
leaq 0x32632(%rip), %rbp # 0xb3575
movslq %r14d, %rax
leaq (%rsp,%rax), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x1a0(%rsp,%rbx,8), %rdx
movq 0x200(%rsp,%rbx,8), %rcx
movq %rbp, %rsi
xorl %eax, %eax
callq 0x30a0
movq %r12, %rdi
callq 0x30f0
movq %rax, %r14
incq %rbx
movq %r13, %rdi
callq 0x65319
cmpq %rbx, %rax
jg 0x80f43
jmp 0x80f90
leaq 0x240(%rsp), %r12
movslq %r14d, %rax
movw $0x5d, 0x240(%rsp,%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x18f07
movq 0xb0(%rsp), %rbx
movq 0x58(%rsp), %r14
movq 0x120(%rsp), %r13
movq (%rbx), %rcx
cmpl $0x0, 0x128(%rsp)
js 0x80fdc
leaq 0x5b93f(%rip), %rax # 0xdc910
movq (%rax), %rax
movq 0x18(%rax,%r14,8), %rax
movl (%rax,%rcx,4), %ecx
movq %rcx, 0x50(%rsp)
xorl %edi, %edi
leaq 0x540(%rsp), %r8
leaq 0x500(%rsp), %r9
xorl %eax, %eax
movq 0x640(%rsp,%rax,8), %rdx
testq %rdx, %rdx
je 0x81032
movq %rdi, 0x440(%rsp,%rax,8)
movq 0x340(%rsp,%rax,8), %rcx
subq 0x3c0(%rsp,%rax,8), %rcx
addq %rdx, %rcx
movq %rcx, 0x540(%rsp,%rax,8)
movq %rdi, 0x480(%rsp,%rax,8)
movq %r9, %rdx
jmp 0x810a2
movq 0x380(%rsp,%rax,8), %rdx
movq %rdx, 0x480(%rsp,%rax,8)
cmpq %rax, %r13
jne 0x8107c
leaq -0x1(,%rdx,2), %rcx
movq %rcx, 0x500(%rsp,%rax,8)
movq 0x340(%rsp,%rax,8), %rcx
subq 0x3c0(%rsp,%rax,8), %rcx
leaq (%rdx,%rcx), %rsi
incq %rsi
movq %rsi, 0x440(%rsp,%rax,8)
leaq (%rcx,%rdx,2), %rcx
jmp 0x8109f
movq 0x340(%rsp,%rax,8), %rcx
subq 0x3c0(%rsp,%rax,8), %rcx
addq %rdx, %rcx
movq %rcx, 0x500(%rsp,%rax,8)
movq %rdx, 0x440(%rsp,%rax,8)
movq %r8, %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x80ff5
leaq 0x5b7ff(%rip), %rax # 0xdc8b8
movq (%rax), %r11
movq 0x30(%rsp), %rax
leaq (%r11,%rax), %rbp
movswq (%r11,%rax), %r10
movl 0x224(%r11,%rax), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc4(%rsp)
cmpl $0x3, %ecx
movq %r10, 0x8(%rsp)
movq %r11, 0x18(%rsp)
movq %rax, 0x130(%rsp)
jae 0x811c1
movq 0xa8(%rsp), %rax
cqto
idivq 0x260(%rbp)
movl %edx, 0x70(%rsp)
movl %r10d, %esi
cmpw $0x2, %r10w
jl 0x81157
movl 0x70(%rsp), %edx
movq 0xa0(%rsp), %rax
leaq (%r11,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x74(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x81132
testw %r10w, %r10w
jle 0x81491
movq 0x110(%rsp), %rax
addq %r11, %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
movslq 0x70(%rsp,%rcx), %rdx
movq (%rax,%rcx,2), %rdi
movq %rdi, %r8
imulq %rdx, %r8
incq %r8
movq %r8, 0x240(%rsp,%rcx,2)
incq %rdx
imulq %rdi, %rdx
movq %rdx, 0xd0(%rsp,%rcx,2)
movq -0x1f8(%rax,%rcx,2), %rdi
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
movq %rdx, 0xd0(%rsp,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x81172
jmp 0x81491
cmpl $0x4, %eax
je 0x8121b
testl %eax, %eax
jne 0x81491
movq 0x2a8(%rbp), %rax
testq %rax, %rax
je 0x812f4
cmpq %rax, 0x10(%rsp)
jge 0x81452
testw %r10w, %r10w
jle 0x813bc
movq 0x98(%rsp), %rax
leaq (%r11,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r10
jne 0x81206
jmp 0x813c1
movq 0xa8(%rsp), %rax
cqto
idivq 0x260(%rbp)
movl %edx, 0x70(%rsp)
movl %r10d, %esi
cmpw $0x2, %r10w
jl 0x8127b
movl 0x70(%rsp), %edx
movq 0xa0(%rsp), %rax
leaq (%r11,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x74(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x81256
testw %r10w, %r10w
jle 0x81491
movq 0x30(%rsp), %rax
movq 0x1e8(%r11,%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x70(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x240(%rsp,%rcx,2)
movq 0x260(%rbp,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x812d2
movq 0x1e8(%rbp), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x812d7
movq 0x30(%rbp,%rcx,2), %rdi
movq %rdi, 0xd0(%rsp,%rcx,2)
addl 0x260(%rbp,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x8129a
jmp 0x81491
testw %r10w, %r10w
jle 0x8131f
movq 0x98(%rsp), %rax
leaq (%r11,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r10
jne 0x8130d
jmp 0x81324
movl $0x1, %eax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
js 0x81452
cmpq %rax, %rcx
jge 0x81452
testw %r10w, %r10w
jle 0x81491
movq 0x1e8(%rbp), %rcx
movq 0x90(%rsp), %rax
leaq (%r11,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%rdi,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%r8,8), %r11
movq %r11, 0x240(%rsp,%rdi,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x81392
movq 0xd4e70(%rsi,%rdi,8), %rdx
jmp 0x8139a
movq 0x8(%r10,%r8,8), %rdx
decq %rdx
movq 0x8(%rsp), %r10
addq %r9, %r8
movq %rdx, 0xd0(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %r10
movq 0x18(%rsp), %r11
jne 0x81362
jmp 0x81491
movl $0x1, %eax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
js 0x81452
cmpq %rax, %rcx
jge 0x81452
testw %r10w, %r10w
jle 0x81491
movq 0x1e8(%rbp), %rcx
movq 0x90(%rsp), %rax
leaq (%r11,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%rdi,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%r8,8), %r11
movq %r11, 0x240(%rsp,%rdi,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x8142b
movq 0xd4e70(%rsi,%rdi,8), %rdx
jmp 0x81433
movq 0x8(%r10,%r8,8), %rdx
decq %rdx
movq 0x8(%rsp), %r10
addq %r9, %r8
movq %rdx, 0xd0(%rsp,%rdi,8)
incq %rdi
cmpq %rdi, %r10
movq 0x18(%rsp), %r11
jne 0x813fb
jmp 0x81491
testw %r10w, %r10w
jle 0x81491
leaq (,%r10,8), %r12
leaq 0x240(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3170
leaq 0xd0(%rsp), %rdi
movl $0xff, %esi
movq %r12, %rdx
callq 0x3170
movq 0x18(%rsp), %r11
movq 0x8(%rsp), %r10
movq %r10, %rbx
decq %rbx
jne 0x814c5
movq 0xd0(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0xc0(%r11,%rcx), %rcx
subq 0x240(%rsp), %rax
leaq (%rax,%rcx,2), %rax
incq %rax
movq %rax, 0x4c0(%rsp)
cmpw $0x2, %r10w
jl 0x81522
movq 0x118(%rsp), %rax
addq %r11, %rax
movl $0x1, %r12d
xorl %ecx, %ecx
xorl %r14d, %r14d
movq 0x480(%rsp,%rcx,8), %rdx
imulq %r12, %rdx
addq %rdx, %r14
movq 0xd0(%rsp,%rcx,8), %rdx
movq (%rax,%rcx,8), %rsi
subq 0x240(%rsp,%rcx,8), %rdx
leaq (%rdx,%rsi,2), %rdx
incq %rdx
movq %rdx, 0x4c0(%rsp,%rcx,8)
imulq %rdx, %r12
incq %rcx
cmpq %rcx, %rbx
jne 0x814e2
jmp 0x8152b
movl $0x1, %r12d
xorl %r14d, %r14d
imulq 0x478(%rsp,%r10,8), %r12
movq 0x1e0(%rbp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x140(%rsp)
movslq 0x18(%rbp), %rax
movq %rax, 0x138(%rsp)
cmpl $0x3, 0xc4(%rsp)
jae 0x81630
movq 0xa8(%rsp), %rax
cqto
idivq 0x260(%rbp)
movl %edx, 0x70(%rsp)
movl %r10d, %esi
cmpw $0x2, %r10w
jl 0x815c6
movl 0x70(%rsp), %edx
movq 0xa0(%rsp), %rax
leaq (%r11,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x74(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x815a1
testw %r10w, %r10w
jle 0x81942
movq 0x110(%rsp), %rax
addq %r11, %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
movslq 0x70(%rsp,%rcx), %rdx
movq (%rax,%rcx,2), %rdi
movq %rdi, %r8
imulq %rdx, %r8
incq %r8
movq %r8, 0x240(%rsp,%rcx,2)
incq %rdx
imulq %rdi, %rdx
movq %rdx, 0xd0(%rsp,%rcx,2)
movq -0x1f8(%rax,%rcx,2), %rdi
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
movq %rdx, 0xd0(%rsp,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x815e1
jmp 0x81942
movq 0x130(%rsp), %rax
cmpl $0x4, %eax
je 0x81692
testl %eax, %eax
jne 0x81942
movq 0x2a8(%rbp), %rax
testq %rax, %rax
je 0x8176b
cmpq %rax, 0x10(%rsp)
jge 0x81796
testw %r10w, %r10w
jle 0x8186e
movq 0x98(%rsp), %rax
leaq (%r11,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r10
jne 0x8167d
jmp 0x81873
movq 0xa8(%rsp), %rax
cqto
idivq 0x260(%rbp)
movl %edx, 0x70(%rsp)
movl %r10d, %esi
cmpw $0x2, %r10w
jl 0x816f2
movl 0x70(%rsp), %edx
movq 0xa0(%rsp), %rax
leaq (%r11,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x74(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x816cd
testw %r10w, %r10w
jle 0x81942
movq 0x30(%rsp), %rax
movq 0x1e8(%r11,%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x70(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x240(%rsp,%rcx,2)
movq 0x260(%rbp,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x81749
movq 0x1e8(%rbp), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x8174e
movq 0x30(%rbp,%rcx,2), %rdi
movq %rdi, 0xd0(%rsp,%rcx,2)
addl 0x260(%rbp,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x81711
jmp 0x81942
testw %r10w, %r10w
jle 0x817d1
movq 0x98(%rsp), %rax
leaq (%r11,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r10
jne 0x81784
jmp 0x817d6
testw %r10w, %r10w
jle 0x81942
movzwl %r10w, %edx
shll $0x3, %edx
leaq 0x240(%rsp), %rdi
xorl %esi, %esi
callq 0x3170
movq 0x8(%rsp), %rdx
shlq $0x3, %rdx
leaq 0xd0(%rsp), %rdi
movl $0xff, %esi
jmp 0x81933
movl $0x1, %eax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
js 0x81904
cmpq %rax, %rcx
jge 0x81904
testw %r10w, %r10w
jle 0x81942
movq 0x1e8(%rbp), %rcx
movq 0x90(%rsp), %rax
leaq (%r11,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x240(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x81844
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x8184c
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
movq 0x8(%rsp), %r10
addq %r9, %rdi
movq %rdx, 0xd0(%rsp,%r8,8)
incq %r8
cmpq %r8, %r10
movq 0x18(%rsp), %r11
jne 0x81814
jmp 0x81942
movl $0x1, %eax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
js 0x81904
cmpq %rax, %rcx
jge 0x81904
testw %r10w, %r10w
jle 0x81942
movq 0x1e8(%rbp), %rcx
movq 0x90(%rsp), %rax
leaq (%r11,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x240(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x818dd
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x818e5
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
movq 0x8(%rsp), %r10
addq %r9, %rdi
movq %rdx, 0xd0(%rsp,%r8,8)
incq %r8
cmpq %r8, %r10
movq 0x18(%rsp), %r11
jne 0x818ad
jmp 0x81942
testw %r10w, %r10w
jle 0x81942
movq %r10, %rbp
shlq $0x3, %rbp
leaq 0x240(%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3170
leaq 0xd0(%rsp), %rdi
movl $0xff, %esi
movq %rbp, %rdx
callq 0x3170
movq 0x18(%rsp), %r11
movq 0x8(%rsp), %r10
testq %rbx, %rbx
jne 0x81973
movq 0xd0(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0xc0(%r11,%rcx), %rcx
subq 0x240(%rsp), %rax
leaq (%rax,%rcx,2), %rax
incq %rax
movq %rax, 0x4c0(%rsp)
cmpw $0x2, %r10w
jl 0x819cb
addq 0x118(%rsp), %r11
movl $0x1, %ebp
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x440(%rsp,%rcx,8), %rdx
imulq %rbp, %rdx
addq %rdx, %rax
movq 0xd0(%rsp,%rcx,8), %rdx
movq (%r11,%rcx,8), %rsi
subq 0x240(%rsp,%rcx,8), %rdx
leaq (%rdx,%rsi,2), %rdx
incq %rdx
movq %rdx, 0x4c0(%rsp,%rcx,8)
imulq %rdx, %rbp
incq %rcx
cmpq %rcx, %rbx
jne 0x8198b
jmp 0x819d2
movl $0x1, %ebp
xorl %eax, %eax
imulq 0x438(%rsp,%r10,8), %rbp
movq 0xb8(%rsp), %rcx
movl %ecx, 0x180(%rsp)
movl %ecx, 0x160(%rsp)
cmpw $0x1, %r15w
movq 0x150(%rsp), %r8
je 0x81a45
movl 0x180(%rsp), %ecx
movl 0x160(%rsp), %edx
xorl %esi, %esi
movl 0x4c0(%rsp,%rsi,8), %edi
imull %edi, %edx
movl %edx, 0x160(%rsp,%rsi,4)
imull %edi, %ecx
movl %ecx, 0x180(%rsp,%rsi,4)
movl %edx, 0x164(%rsp,%rsi,4)
movl %ecx, 0x184(%rsp,%rsi,4)
leaq 0x1(%rsi), %rdi
movq %rdi, %rsi
cmpq %rdi, %r8
jne 0x81a10
addq %r14, %r12
movq 0x138(%rsp), %rdx
imulq %rdx, %r12
movq 0x140(%rsp), %rcx
addq %rcx, %r12
addq %rax, %rbp
imulq %rdx, %rbp
addq %rcx, %rbp
xorl %eax, %eax
movl 0x540(%rsp,%rax,8), %ecx
subl 0x440(%rsp,%rax,8), %ecx
incl %ecx
movl %ecx, 0x1e0(%rsp,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0x81a6b
movl $0x1, %r14d
xorl %eax, %eax
movq 0x500(%rsp,%rax,8), %rcx
subq 0x480(%rsp,%rax,8), %rcx
incq %rcx
imulq %rcx, %r14
incq %rax
cmpq %rax, %r15
jne 0x81a92
movl 0x1e0(%rsp), %eax
imull 0xb8(%rsp), %eax
movl %eax, 0x1e0(%rsp)
movq %r12, %rdi
movl 0x6c(%rsp), %esi
leaq 0x180(%rsp), %rdx
leaq 0x1e0(%rsp), %r12
movq %r12, %rcx
movq 0x40(%rsp), %rbx
movq %rbx, %r8
callq 0xa51d8
movq %rbx, %r8
leaq 0x5aeb0(%rip), %rax # 0xdc9a8
movq 0x28(%rsp), %rcx
cmpq %rcx, (%rax)
je 0x81c80
imulq 0xb8(%rsp), %r14
leaq 0x5ada2(%rip), %rax # 0xdc8b8
movq (%rax), %rax
addq 0x30(%rsp), %rax
movslq 0xa0(%rax,%r13,4), %rbx
testb $0x1, %bl
jne 0x81b56
testb $0x1, 0x400(%rsp,%r13,8)
jne 0x81b8a
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0x5968c
jmp 0x81b9c
decq %rbx
movq 0x400(%rsp,%r13,8), %rax
testb $0x1, %al
jne 0x81bcc
cmpq %rbx, %rax
je 0x81bde
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0x5968c
jmp 0x81bde
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
callq 0x59542
testb $0x1, 0x400(%rsp,%r13,8)
jne 0x81c5c
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
movq 0x28(%rsp), %rcx
callq 0x59542
movq 0x38(%rsp), %r8
jmp 0x81c80
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
callq 0x59542
movq 0x400(%rsp,%r13,8), %rax
testb $0x1, %al
jne 0x81c0d
testq %rax, %rax
movq 0x28(%rsp), %rcx
je 0x81c30
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
movq 0x28(%rsp), %rcx
callq 0x59542
jmp 0x81c2b
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0x5968c
movq 0x28(%rsp), %rcx
cmpq $0x0, 0x400(%rsp,%r13,8)
jne 0x81c4d
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
callq 0x59542
movq 0x38(%rsp), %r8
cmpq %rbx, 0x400(%rsp,%r13,8)
jne 0x81c80
movq 0x60(%rsp), %rdi
movq 0x38(%rsp), %rbx
movq %rbx, %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0x5968c
movq %rbx, %r8
movq %rbp, %rdi
movl 0x6c(%rsp), %esi
leaq 0x160(%rsp), %rdx
movq %r12, %rcx
callq 0xa528c
movq %r13, %rdi
movq %r15, %rsi
leaq 0x3c0(%rsp), %rdx
leaq 0x340(%rsp), %rcx
leaq 0x1a0(%rsp), %rbx
movq %rbx, %r8
leaq 0x200(%rsp), %r14
movq %r14, %r9
leaq 0x380(%rsp), %rax
pushq %rax
leaq 0x608(%rsp), %rax
pushq %rax
callq 0x7e0de
addq $0x10, %rsp
movq 0x158(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq 0xc8(%rsp), %rcx
movq 0xb0(%rsp), %rbx
movq %rbx, %r8
leaq 0x148(%rsp), %r9
callq 0x670f6
testq %rax, %rax
leaq 0x240(%rsp), %rbp
jne 0x81e31
movups 0x3182c(%rip), %xmm0 # 0xb3553
movaps %xmm0, 0x240(%rsp)
movabsq $0x203a6e6f696765, %rax # imm = 0x203A6E6F696765
movq %rax, 0x24f(%rsp)
leaq 0x5ab70(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq 0x30(%rsp), %rcx
leaq (%rax,%rcx), %rsi
addq $0x1f0, %rsi # imm = 0x1F0
leaq 0x256(%rsp), %rdi
callq 0x3250
movq %rbp, %rdi
callq 0x30f0
cltq
leaq (%rsp,%rax), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x1a0(%rsp), %rdx
movq 0x200(%rsp), %rcx
leaq 0x317d6(%rip), %rsi # 0xb356a
xorl %eax, %eax
callq 0x30a0
movq %rbp, %r13
movq %rbp, %rdi
callq 0x30f0
movq %rax, %r14
movq %r12, %rdi
callq 0x65319
cmpq $0x2, %rax
jl 0x81e06
movl $0x1, %ebx
leaq 0x317b2(%rip), %rbp # 0xb3575
movslq %r14d, %rax
leaq (%rsp,%rax), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x1a0(%rsp,%rbx,8), %rdx
movq 0x200(%rsp,%rbx,8), %rcx
movq %rbp, %rsi
xorl %eax, %eax
callq 0x30a0
movq %r13, %rdi
callq 0x30f0
movq %rax, %r14
incq %rbx
movq %r12, %rdi
callq 0x65319
cmpq %rbx, %rax
jg 0x81dc3
movslq %r14d, %rax
movw $0x5d, 0x240(%rsp,%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x18f07
movq 0xb0(%rsp), %rbx
movq %r13, %rbp
movq 0x120(%rsp), %r13
movq (%rbx), %rsi
cmpl $0x0, 0x128(%rsp)
js 0x81e57
leaq 0x5aacb(%rip), %rax # 0xdc910
movq (%rax), %rax
movq 0x58(%rsp), %r14
movq 0x18(%rax,%r14,8), %rax
movl (%rax,%rsi,4), %esi
jmp 0x81e5c
movq 0x58(%rsp), %r14
movq 0x60(%rsp), %rax
incq %rax
movq %rax, 0x28(%rsp)
xorl %eax, %eax
movq 0x3c0(%rsp,%rax,8), %rcx
cmpq %rax, %r13
jne 0x81e90
movq %rcx, %rdx
subq 0x380(%rsp,%rax,8), %rdx
movq %rdx, 0x580(%rsp,%rax,8)
decq %rcx
jmp 0x81ea0
movq %rcx, 0x580(%rsp,%rax,8)
movq 0x340(%rsp,%rax,8), %rcx
movq %rcx, 0x5c0(%rsp,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x81e6b
xorl %eax, %eax
cmpq %rax, %r13
jne 0x81ece
movq 0x5c0(%rsp,%rax,8), %rcx
testq %rcx, %rcx
jle 0x81ee8
movq 0x580(%rsp,%rax,8), %rdx
jmp 0x81efe
movq 0x580(%rsp,%rax,8), %rcx
movq %rcx, 0x1a0(%rsp,%rax,8)
movq 0x5c0(%rsp,%rax,8), %rcx
jmp 0x81f06
movq 0x600(%rsp,%rax,8), %rcx
movq %rcx, %rdx
subq 0x380(%rsp,%rax,8), %rdx
incq %rdx
movq %rdx, 0x1a0(%rsp,%rax,8)
movq %rcx, 0x200(%rsp,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x81eb2
movq %rsi, 0x50(%rsp)
movq %r12, %rdi
leaq 0x1a0(%rsp), %rsi
leaq 0x200(%rsp), %rdx
movq 0xc8(%rsp), %rcx
movq %rbx, %r8
leaq 0x148(%rsp), %r9
callq 0x670f6
testq %rax, %rax
jne 0x82068
movups 0x315fd(%rip), %xmm0 # 0xb3553
movaps %xmm0, 0x240(%rsp)
movabsq $0x203a6e6f696765, %rax # imm = 0x203A6E6F696765
movq %rax, 0x24f(%rsp)
leaq 0x5a941(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq 0x30(%rsp), %rcx
leaq (%rax,%rcx), %rsi
addq $0x1f0, %rsi # imm = 0x1F0
leaq 0x256(%rsp), %rdi
callq 0x3250
movq %rbp, %rdi
callq 0x30f0
cltq
leaq (%rsp,%rax), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x1a0(%rsp), %rdx
movq 0x200(%rsp), %rcx
leaq 0x315a7(%rip), %rsi # 0xb356a
xorl %eax, %eax
callq 0x30a0
movq %r12, %rbx
movq %rbp, %r12
movq %rbp, %rdi
callq 0x30f0
movq %rax, %r14
movq %rbx, %r13
movq %rbx, %rdi
callq 0x65319
cmpq $0x2, %rax
jl 0x8203b
movl $0x1, %ebx
leaq 0x3157d(%rip), %rbp # 0xb3575
movslq %r14d, %rax
leaq (%rsp,%rax), %rdi
addq $0x240, %rdi # imm = 0x240
movq 0x1a0(%rsp,%rbx,8), %rdx
movq 0x200(%rsp,%rbx,8), %rcx
movq %rbp, %rsi
xorl %eax, %eax
callq 0x30a0
movq %r12, %rdi
callq 0x30f0
movq %rax, %r14
incq %rbx
movq %r13, %rdi
callq 0x65319
cmpq %rbx, %rax
jg 0x81ff8
movslq %r14d, %rax
movw $0x5d, 0x240(%rsp,%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x18f07
movq 0xb0(%rsp), %rbx
movq 0x58(%rsp), %r14
movq 0x120(%rsp), %r13
movq (%rbx), %r9
cmpl $0x0, 0x128(%rsp)
js 0x82088
leaq 0x5a894(%rip), %rax # 0xdc910
movq (%rax), %rax
movq 0x18(%rax,%r14,8), %rax
movslq (%rax,%r9,4), %r9
xorl %esi, %esi
leaq 0x540(%rsp), %rdi
leaq 0x500(%rsp), %r8
xorl %eax, %eax
movq 0x640(%rsp,%rax,8), %rdx
testq %rdx, %rdx
je 0x820d9
movq %rsi, 0x440(%rsp,%rax,8)
movq 0x340(%rsp,%rax,8), %rcx
subq 0x3c0(%rsp,%rax,8), %rcx
addq %rdx, %rcx
movq %rcx, 0x540(%rsp,%rax,8)
movq %rsi, 0x480(%rsp,%rax,8)
movq %r8, %rdx
jmp 0x82154
cmpq %rax, %r13
jne 0x8211e
movq 0x340(%rsp,%rax,8), %rdx
subq 0x3c0(%rsp,%rax,8), %rdx
leaq 0x1(%rdx), %rcx
movq %rcx, 0x480(%rsp,%rax,8)
movq 0x380(%rsp,%rax,8), %rcx
addq %rcx, %rdx
movq %rdx, 0x500(%rsp,%rax,8)
movq $0x0, 0x440(%rsp,%rax,8)
decq %rcx
jmp 0x82151
movq 0x380(%rsp,%rax,8), %rdx
movq %rdx, 0x480(%rsp,%rax,8)
movq 0x340(%rsp,%rax,8), %rcx
subq 0x3c0(%rsp,%rax,8), %rcx
addq %rdx, %rcx
movq %rcx, 0x500(%rsp,%rax,8)
movq %rdx, 0x440(%rsp,%rax,8)
movq %rdi, %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x8209c
leaq 0x5a74d(%rip), %rax # 0xdc8b8
movq (%rax), %r11
movq 0x30(%rsp), %rax
leaq (%r11,%rax), %rbp
movswq (%r11,%rax), %r10
movl 0x224(%r11,%rax), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc4(%rsp)
cmpl $0x3, %ecx
movq %r9, 0x58(%rsp)
movq %r10, 0x8(%rsp)
movq %r11, 0x18(%rsp)
movq %rax, 0x130(%rsp)
jae 0x82278
movq 0xa8(%rsp), %rax
cqto
idivq 0x260(%rbp)
movl %edx, 0x70(%rsp)
movl %r10d, %esi
cmpw $0x2, %r10w
jl 0x8220e
movl 0x70(%rsp), %edx
movq 0xa0(%rsp), %rax
leaq (%r11,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x74(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x821e9
testw %r10w, %r10w
jle 0x82548
movq 0x110(%rsp), %rax
addq %r11, %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
movslq 0x70(%rsp,%rcx), %rdx
movq (%rax,%rcx,2), %rdi
movq %rdi, %r8
imulq %rdx, %r8
incq %r8
movq %r8, 0x240(%rsp,%rcx,2)
incq %rdx
imulq %rdi, %rdx
movq %rdx, 0xd0(%rsp,%rcx,2)
movq -0x1f8(%rax,%rcx,2), %rdi
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
movq %rdx, 0xd0(%rsp,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x82229
jmp 0x82548
cmpl $0x4, %eax
je 0x822d2
testl %eax, %eax
jne 0x82548
movq 0x2a8(%rbp), %rax
testq %rax, %rax
je 0x823ab
cmpq %rax, 0x10(%rsp)
jge 0x82509
testw %r10w, %r10w
jle 0x82473
movq 0x98(%rsp), %rax
leaq (%r11,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r10
jne 0x822bd
jmp 0x82478
movq 0xa8(%rsp), %rax
cqto
idivq 0x260(%rbp)
movl %edx, 0x70(%rsp)
movl %r10d, %esi
cmpw $0x2, %r10w
jl 0x82332
movl 0x70(%rsp), %edx
movq 0xa0(%rsp), %rax
leaq (%r11,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x74(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x8230d
testw %r10w, %r10w
jle 0x82548
movq 0x30(%rsp), %rax
movq 0x1e8(%r11,%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x70(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x240(%rsp,%rcx,2)
movq 0x260(%rbp,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x82389
movq 0x1e8(%rbp), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x8238e
movq 0x30(%rbp,%rcx,2), %rdi
movq %rdi, 0xd0(%rsp,%rcx,2)
addl 0x260(%rbp,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x82351
jmp 0x82548
testw %r10w, %r10w
jle 0x823d6
movq 0x98(%rsp), %rax
leaq (%r11,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r10
jne 0x823c4
jmp 0x823db
movl $0x1, %eax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
js 0x82509
cmpq %rax, %rcx
jge 0x82509
testw %r10w, %r10w
jle 0x82548
movq 0x1e8(%rbp), %rcx
movq 0x90(%rsp), %rax
leaq (%r11,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x240(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x82449
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x82451
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
movq 0x8(%rsp), %r10
addq %r9, %rdi
movq %rdx, 0xd0(%rsp,%r8,8)
incq %r8
cmpq %r8, %r10
movq 0x18(%rsp), %r11
jne 0x82419
jmp 0x82548
movl $0x1, %eax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
js 0x82509
cmpq %rax, %rcx
jge 0x82509
testw %r10w, %r10w
jle 0x82548
movq 0x1e8(%rbp), %rcx
movq 0x90(%rsp), %rax
leaq (%r11,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x240(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x824e2
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x824ea
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
movq 0x8(%rsp), %r10
addq %r9, %rdi
movq %rdx, 0xd0(%rsp,%r8,8)
incq %r8
cmpq %r8, %r10
movq 0x18(%rsp), %r11
jne 0x824b2
jmp 0x82548
testw %r10w, %r10w
jle 0x82548
leaq (,%r10,8), %r12
leaq 0x240(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3170
leaq 0xd0(%rsp), %rdi
movl $0xff, %esi
movq %r12, %rdx
callq 0x3170
movq 0x18(%rsp), %r11
movq 0x8(%rsp), %r10
movq %r10, %rbx
decq %rbx
jne 0x8257c
movq 0xd0(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0xc0(%r11,%rcx), %rcx
subq 0x240(%rsp), %rax
leaq (%rax,%rcx,2), %rax
incq %rax
movq %rax, 0x4c0(%rsp)
cmpw $0x2, %r10w
jl 0x825d9
movq 0x118(%rsp), %rax
addq %r11, %rax
movl $0x1, %r12d
xorl %r14d, %r14d
xorl %ecx, %ecx
movq 0x480(%rsp,%rcx,8), %rdx
imulq %r12, %rdx
addq %rdx, %r14
movq 0xd0(%rsp,%rcx,8), %rdx
movq (%rax,%rcx,8), %rsi
subq 0x240(%rsp,%rcx,8), %rdx
leaq (%rdx,%rsi,2), %rdx
incq %rdx
movq %rdx, 0x4c0(%rsp,%rcx,8)
imulq %rdx, %r12
incq %rcx
cmpq %rcx, %rbx
jne 0x82599
jmp 0x825e2
movl $0x1, %r12d
xorl %r14d, %r14d
imulq 0x478(%rsp,%r10,8), %r12
movq 0x1e0(%rbp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x140(%rsp)
movslq 0x18(%rbp), %rax
movq %rax, 0x138(%rsp)
cmpl $0x3, 0xc4(%rsp)
jae 0x826e7
movq 0xa8(%rsp), %rax
cqto
idivq 0x260(%rbp)
movl %edx, 0x70(%rsp)
movl %r10d, %esi
cmpw $0x2, %r10w
jl 0x8267d
movl 0x70(%rsp), %edx
movq 0xa0(%rsp), %rax
leaq (%r11,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x74(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x82658
testw %r10w, %r10w
jle 0x829f9
movq 0x110(%rsp), %rax
addq %r11, %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
movslq 0x70(%rsp,%rcx), %rdx
movq (%rax,%rcx,2), %rdi
movq %rdi, %r8
imulq %rdx, %r8
incq %r8
movq %r8, 0x240(%rsp,%rcx,2)
incq %rdx
imulq %rdi, %rdx
movq %rdx, 0xd0(%rsp,%rcx,2)
movq -0x1f8(%rax,%rcx,2), %rdi
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
movq %rdx, 0xd0(%rsp,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x82698
jmp 0x829f9
movq 0x130(%rsp), %rax
cmpl $0x4, %eax
je 0x82749
testl %eax, %eax
jne 0x829f9
movq 0x2a8(%rbp), %rax
testq %rax, %rax
je 0x82822
cmpq %rax, 0x10(%rsp)
jge 0x8284d
testw %r10w, %r10w
jle 0x82925
movq 0x98(%rsp), %rax
leaq (%r11,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r10
jne 0x82734
jmp 0x8292a
movq 0xa8(%rsp), %rax
cqto
idivq 0x260(%rbp)
movl %edx, 0x70(%rsp)
movl %r10d, %esi
cmpw $0x2, %r10w
jl 0x827a9
movl 0x70(%rsp), %edx
movq 0xa0(%rsp), %rax
leaq (%r11,%rax), %rdi
leaq -0x1(%rsi), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %rcx
subl %edx, %ecx
movslq %ecx, %rax
cqto
idivq -0x8(%rdi,%r9,8)
movq %rax, %rcx
movslq %ecx, %rax
cqto
idivq (%rdi,%r9,8)
movl %edx, 0x74(%rsp,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x82784
testw %r10w, %r10w
jle 0x829f9
movq 0x30(%rsp), %rax
movq 0x1e8(%r11,%rax), %rax
shlq $0x2, %rsi
xorl %ecx, %ecx
xorl %edx, %edx
movslq 0x70(%rsp,%rcx), %r8
movslq %edx, %rdi
addq %r8, %rdi
movq (%rax,%rdi,8), %r9
movq %r9, 0x240(%rsp,%rcx,2)
movq 0x260(%rbp,%rcx,2), %r9
decq %r9
cmpq %r8, %r9
jle 0x82800
movq 0x1e8(%rbp), %r8
movq 0x8(%r8,%rdi,8), %rdi
decq %rdi
jmp 0x82805
movq 0x30(%rbp,%rcx,2), %rdi
movq %rdi, 0xd0(%rsp,%rcx,2)
addl 0x260(%rbp,%rcx,2), %edx
addq $0x4, %rcx
cmpq %rcx, %rsi
jne 0x827c8
jmp 0x829f9
testw %r10w, %r10w
jle 0x82888
movq 0x98(%rsp), %rax
leaq (%r11,%rax), %rcx
movl $0x1, %eax
xorl %edx, %edx
movslq (%rcx,%rdx,4), %rsi
imulq %rsi, %rax
incq %rdx
cmpq %rdx, %r10
jne 0x8283b
jmp 0x8288d
testw %r10w, %r10w
jle 0x829f9
movzwl %r10w, %edx
shll $0x3, %edx
leaq 0x240(%rsp), %rdi
xorl %esi, %esi
callq 0x3170
movq 0x8(%rsp), %rdx
shlq $0x3, %rdx
leaq 0xd0(%rsp), %rdi
movl $0xff, %esi
jmp 0x829ea
movl $0x1, %eax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
js 0x829bb
cmpq %rax, %rcx
jge 0x829bb
testw %r10w, %r10w
jle 0x829f9
movq 0x1e8(%rbp), %rcx
movq 0x90(%rsp), %rax
leaq (%r11,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x240(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x828fb
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x82903
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
movq 0x8(%rsp), %r10
addq %r9, %rdi
movq %rdx, 0xd0(%rsp,%r8,8)
incq %r8
cmpq %r8, %r10
movq 0x18(%rsp), %r11
jne 0x828cb
jmp 0x829f9
movl $0x1, %eax
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
js 0x829bb
cmpq %rax, %rcx
jge 0x829bb
testw %r10w, %r10w
jle 0x829f9
movq 0x1e8(%rbp), %rcx
movq 0x90(%rsp), %rax
leaq (%r11,%rax), %rsi
xorl %edi, %edi
movq 0x10(%rsp), %rax
xorl %r8d, %r8d
movslq 0xd4ee0(%rsi,%r8,4), %r9
cqto
idivq %r9
leaq (%rcx,%rdx,8), %r10
movq (%r10,%rdi,8), %r11
movq %r11, 0x240(%rsp,%r8,8)
leaq -0x1(%r9), %r11
cmpq %r11, %rdx
jne 0x82994
movq 0xd4e70(%rsi,%r8,8), %rdx
jmp 0x8299c
movq 0x8(%r10,%rdi,8), %rdx
decq %rdx
movq 0x8(%rsp), %r10
addq %r9, %rdi
movq %rdx, 0xd0(%rsp,%r8,8)
incq %r8
cmpq %r8, %r10
movq 0x18(%rsp), %r11
jne 0x82964
jmp 0x829f9
testw %r10w, %r10w
jle 0x829f9
movq %r10, %rbp
shlq $0x3, %rbp
leaq 0x240(%rsp), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x3170
leaq 0xd0(%rsp), %rdi
movl $0xff, %esi
movq %rbp, %rdx
callq 0x3170
movq 0x18(%rsp), %r11
movq 0x8(%rsp), %r10
testq %rbx, %rbx
jne 0x82a2a
movq 0xd0(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0xc0(%r11,%rcx), %rcx
subq 0x240(%rsp), %rax
leaq (%rax,%rcx,2), %rax
incq %rax
movq %rax, 0x4c0(%rsp)
cmpw $0x2, %r10w
jl 0x82a82
addq 0x118(%rsp), %r11
movl $0x1, %ebp
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x440(%rsp,%rcx,8), %rdx
imulq %rbp, %rdx
addq %rdx, %rax
movq 0xd0(%rsp,%rcx,8), %rdx
movq (%r11,%rcx,8), %rsi
subq 0x240(%rsp,%rcx,8), %rdx
leaq (%rdx,%rsi,2), %rdx
incq %rdx
movq %rdx, 0x4c0(%rsp,%rcx,8)
imulq %rdx, %rbp
incq %rcx
cmpq %rcx, %rbx
jne 0x82a42
jmp 0x82a89
movl $0x1, %ebp
xorl %eax, %eax
imulq 0x438(%rsp,%r10,8), %rbp
movq 0xb8(%rsp), %rcx
movl %ecx, 0x180(%rsp)
movl %ecx, 0x160(%rsp)
cmpw $0x1, %r15w
movq 0x150(%rsp), %r8
je 0x82afc
movl 0x180(%rsp), %ecx
movl 0x160(%rsp), %edx
xorl %esi, %esi
movl 0x4c0(%rsp,%rsi,8), %edi
imull %edi, %edx
movl %edx, 0x160(%rsp,%rsi,4)
imull %edi, %ecx
movl %ecx, 0x180(%rsp,%rsi,4)
movl %edx, 0x164(%rsp,%rsi,4)
movl %ecx, 0x184(%rsp,%rsi,4)
leaq 0x1(%rsi), %rdi
movq %rdi, %rsi
cmpq %rdi, %r8
jne 0x82ac7
addq %r14, %r12
movq 0x138(%rsp), %rdx
imulq %rdx, %r12
movq 0x140(%rsp), %rcx
addq %rcx, %r12
addq %rax, %rbp
imulq %rdx, %rbp
addq %rcx, %rbp
xorl %eax, %eax
movl 0x540(%rsp,%rax,8), %ecx
subl 0x440(%rsp,%rax,8), %ecx
incl %ecx
movl %ecx, 0x1e0(%rsp,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0x82b22
movl $0x1, %r14d
xorl %eax, %eax
movq 0x500(%rsp,%rax,8), %rcx
subq 0x480(%rsp,%rax,8), %rcx
incq %rcx
imulq %rcx, %r14
incq %rax
cmpq %rax, %r15
jne 0x82b49
movl 0x1e0(%rsp), %eax
imull 0xb8(%rsp), %eax
movl %eax, 0x1e0(%rsp)
movq %r12, %rdi
movl 0x6c(%rsp), %esi
leaq 0x180(%rsp), %rdx
leaq 0x1e0(%rsp), %r12
movq %r12, %rcx
movq 0x40(%rsp), %rbx
movq %rbx, %r8
callq 0xa51d8
leaq 0x59dfc(%rip), %rax # 0xdc9a8
movq 0x58(%rsp), %r9
cmpq %r9, (%rax)
je 0x82d57
imulq 0xb8(%rsp), %r14
leaq 0x59cee(%rip), %rax # 0xdc8b8
movq (%rax), %rax
addq 0x30(%rsp), %rax
movslq 0xa0(%rax,%r13,4), %rbx
testb $0x1, %bl
jne 0x82c08
testb $0x1, 0x400(%rsp,%r13,8)
jne 0x82c37
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movl %r9d, %r8d
callq 0x5968c
jmp 0x82c4e
movq 0x400(%rsp,%r13,8), %rax
testb $0x1, %al
jne 0x82c7a
testq %rax, %rax
je 0x82c96
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movl %r9d, %r8d
callq 0x5968c
jmp 0x82c91
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
movq 0x50(%rsp), %rcx
callq 0x59542
testb $0x1, 0x400(%rsp,%r13,8)
jne 0x82cc3
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
movq 0x50(%rsp), %rcx
callq 0x59542
movq 0x38(%rsp), %rbx
jmp 0x82d57
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
movq 0x50(%rsp), %rcx
callq 0x59542
movq 0x58(%rsp), %r9
decq %rbx
movq 0x400(%rsp,%r13,8), %rax
testb $0x1, %al
jne 0x82ce1
cmpq %rbx, %rax
je 0x82d02
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
movq 0x50(%rsp), %rcx
callq 0x59542
jmp 0x82cfd
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rbx
movq %rbx, %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movq 0x58(%rsp), %r8
jmp 0x82d52
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movl %r9d, %r8d
callq 0x5968c
movq 0x58(%rsp), %r9
cmpq %rbx, 0x400(%rsp,%r13,8)
jne 0x82d28
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl %r14d, %edx
movq 0x50(%rsp), %rcx
callq 0x59542
movq 0x58(%rsp), %r9
cmpq $0x0, 0x400(%rsp,%r13,8)
movq 0x38(%rsp), %rbx
jne 0x82d57
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rbx
movq %rbx, %rsi
movq 0x48(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movl %r9d, %r8d
callq 0x5968c
movq %rbp, %rdi
movl 0x6c(%rsp), %esi
leaq 0x160(%rsp), %rdx
movq %r12, %rcx
movq %rbx, %r8
callq 0xa528c
addq $0x2, 0x60(%rsp)
movq 0x158(%rsp), %rbp
movq 0xb0(%rsp), %rbx
leaq 0x59b2a(%rip), %rax # 0xdc8b8
movq (%rax), %rax
movq 0x30(%rsp), %rcx
cmpl $0x0, 0x220(%rax,%rcx)
je 0x82db3
movq 0x380(%rsp,%r13,8), %rax
addq %rax, %rax
movq %rax, 0x640(%rsp,%r13,8)
incq %r13
cmpq %r15, %r13
jne 0x80bc3
movq 0x38(%rsp), %rdi
callq 0x5d385
movq 0x40(%rsp), %rdi
callq 0x5d385
movq 0xc8(%rsp), %rdi
callq 0x3330
movq %rbx, %rdi
callq 0x3330
movl $0x1, %eax
jmp 0x82df1
xorl %eax, %eax
addq $0x6c8, %rsp # imm = 0x6C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/ghosts.c |
NGA_Create_irreg | int NGA_Create_irreg(int type,int ndim,int dims[],char *name,int block[],int map[])
{
Integer g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer *_ga_map_capi;
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
COPYC2F(block,_ga_work, ndim);
_ga_map_capi = copy_map(block, ndim, map);
_ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
st = wnga_create_irreg(type, (Integer)ndim, _ga_dims, name, _ga_map_capi,
_ga_work, &g_a);
_ga_irreg_flag = 0; /* unset it after creating the array */
free(_ga_map_capi);
if(st==TRUE) return (int) g_a;
else return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8da81
movq %rcx, %r14
movl %esi, %ebp
movl %edi, %r15d
movl %esi, %eax
testl %esi, %esi
jle 0x8da0b
movq %rax, %rcx
movslq (%rdx), %rsi
movq %rsi, 0x48(%rsp,%rcx,8)
addq $0x4, %rdx
decq %rcx
jne 0x8d9fa
testl %ebp, %ebp
jle 0x8da23
movq %r8, %rcx
movslq (%rcx), %rdx
movq %rdx, 0x8(%rsp,%rax,8)
addq $0x4, %rcx
decq %rax
jne 0x8da12
movq %r8, %rdi
movl %ebp, %esi
movq %r9, %rdx
callq 0x8da95
movq %rax, %r12
leaq 0x5101e(%rip), %r13 # 0xdea58
movw $0x1, (%r13)
movslq %r15d, %rdi
movslq %ebp, %rsi
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rdx
leaq 0x10(%rsp), %r9
movq %r14, %rcx
movq %r12, %r8
callq 0x64e4e
movq %rax, %r14
movw $0x0, (%r13)
movq %r12, %rdi
callq 0x3330
cmpq $0x1, %r14
jne 0x8da81
movl 0x8(%rsp), %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Create_irreg64 | int NGA_Create_irreg64(int type,int ndim,int64_t dims[],char *name,int64_t block[],int64_t map[])
{
Integer g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer *_ga_map_capi;
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
COPYC2F(block,_ga_work, ndim);
_ga_map_capi = copy_map64(block, ndim, map);
_ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
st = wnga_create_irreg(type, (Integer)ndim, _ga_dims, name, _ga_map_capi,
_ga_work, &g_a);
_ga_irreg_flag = 0; /* unset it after creating the array */
free(_ga_map_capi);
if(st==TRUE) return (int) g_a;
else return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8dbcf
movq %rcx, %r14
movl %esi, %ebp
movl %edi, %r15d
movl %esi, %eax
testl %esi, %esi
jle 0x8db59
movq %rax, %rcx
movq (%rdx), %rsi
movq %rsi, 0x48(%rsp,%rcx,8)
addq $0x8, %rdx
decq %rcx
jne 0x8db48
testl %ebp, %ebp
jle 0x8db71
movq %r8, %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rsp,%rax,8)
addq $0x8, %rcx
decq %rax
jne 0x8db60
movq %r8, %rdi
movl %ebp, %esi
movq %r9, %rdx
callq 0x8dbe3
movq %rax, %r12
leaq 0x50ed0(%rip), %r13 # 0xdea58
movw $0x1, (%r13)
movslq %r15d, %rdi
movslq %ebp, %rsi
leaq 0x8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rdx
leaq 0x10(%rsp), %r9
movq %r14, %rcx
movq %r12, %r8
callq 0x64e4e
movq %rax, %r14
movw $0x0, (%r13)
movq %r12, %rdi
callq 0x3330
cmpq $0x1, %r14
jne 0x8dbcf
movl 0x8(%rsp), %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Create_irreg_config | int NGA_Create_irreg_config(int type,int ndim,int dims[],char *name,int block[],
int map[], int p_handle)
{
Integer g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer *_ga_map_capi;
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
COPYC2F(block,_ga_work, ndim);
_ga_map_capi = copy_map(block, ndim, map);
_ga_irreg_flag = 1; /* set this flag=1, to indicate array is irregular */
st = wnga_create_irreg_config(type, (Integer)ndim, _ga_dims, name,
_ga_map_capi, _ga_work, (Integer)p_handle, &g_a);
_ga_irreg_flag = 0; /* unset it, after creating array */
free(_ga_map_capi);
if(st==TRUE) return (int) g_a;
else return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8dd22
movq %rcx, %r14
movl %esi, %ebp
movl %edi, %r15d
movl %esi, %eax
testl %esi, %esi
jle 0x8dca1
movq %rax, %rcx
movslq (%rdx), %rsi
movq %rsi, 0x48(%rsp,%rcx,8)
addq $0x4, %rdx
decq %rcx
jne 0x8dc90
testl %ebp, %ebp
jle 0x8dcb9
movq %r8, %rcx
movslq (%rcx), %rdx
movq %rdx, 0x8(%rsp,%rax,8)
addq $0x4, %rcx
decq %rax
jne 0x8dca8
movq %r8, %rdi
movl %ebp, %esi
movq %r9, %rdx
callq 0x8da95
movq %rax, %r12
leaq 0x50d88(%rip), %r13 # 0xdea58
movw $0x1, (%r13)
movslq %r15d, %rdi
movslq %ebp, %rsi
movslq 0xc0(%rsp), %rax
leaq 0x8(%rsp), %r10
leaq 0x50(%rsp), %rdx
leaq 0x10(%rsp), %r9
movq %r14, %rcx
movq %r12, %r8
pushq %r10
pushq %rax
callq 0x64dd3
addq $0x10, %rsp
movq %rax, %r14
movw $0x0, (%r13)
movq %r12, %rdi
callq 0x3330
cmpq $0x1, %r14
jne 0x8dd22
movl 0x8(%rsp), %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Create_ghosts | int NGA_Create_ghosts(int type, int ndim,int dims[], int width[], char *name,
int chunk[])
{
Integer *ptr, g_a;
logical st;
Integer _ga_dims[MAXDIM];
Integer _ga_work[MAXDIM];
Integer _ga_width[MAXDIM];
if(ndim>MAXDIM)return 0;
COPYC2F(dims,_ga_dims, ndim);
COPYC2F(width,_ga_width, ndim);
if(!chunk)ptr=(Integer*)0;
else {
COPYC2F(chunk,_ga_work, ndim);
ptr = _ga_work;
}
st = wnga_create_ghosts((Integer)type, (Integer)ndim, _ga_dims,
_ga_width, name, ptr, &g_a);
if(st==TRUE) return (int) g_a;
else return 0;
} | pushq %rbx
subq $0xd0, %rsp
xorl %ebx, %ebx
cmpl $0x7, %esi
jg 0x8e291
movl %esi, %r10d
testl %esi, %esi
jle 0x8e222
movq %r10, %rax
movslq (%rdx), %r11
movq %r11, 0x88(%rsp,%rax,8)
addq $0x4, %rdx
decq %rax
jne 0x8e20e
testl %esi, %esi
jle 0x8e23a
movq %r10, %rax
movslq (%rcx), %rdx
movq %rdx, 0x8(%rsp,%rax,8)
addq $0x4, %rcx
decq %rax
jne 0x8e229
xorl %ebx, %ebx
testq %r9, %r9
je 0x8e261
leaq 0x50(%rsp), %rax
testl %esi, %esi
jle 0x8e263
decq %r10
movslq (%r9), %rcx
movq %rcx, 0x50(%rsp,%r10,8)
addq $0x4, %r9
addq $-0x1, %r10
jb 0x8e24d
jmp 0x8e263
xorl %eax, %eax
movslq %edi, %rdi
movslq %esi, %rsi
leaq 0x8(%rsp), %rcx
movq %rcx, (%rsp)
leaq 0x90(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rax, %r9
callq 0x64db8
cmpq $0x1, %rax
jne 0x8e291
movl 0x8(%rsp), %ebx
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_chunk | void NGA_Set_chunk(int g_a, int chunk[])
{
Integer aa, *ptr, ndim;
Integer _ga_work[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
if(!chunk)ptr=(Integer*)0;
else {
COPYC2F(chunk,_ga_work, ndim);
ptr = _ga_work;
}
wnga_set_chunk(aa, ptr);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60ab7
testq %r14, %r14
je 0x8e657
movq %rsp, %rsi
testq %rax, %rax
jle 0x8e659
decq %rax
movslq (%r14), %rcx
movq %rcx, (%rsp,%rax,8)
addq $0x4, %r14
addq $-0x1, %rax
jb 0x8e644
jmp 0x8e659
xorl %esi, %esi
movq %rbx, %rdi
callq 0x60510
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_block_cyclic | void NGA_Set_block_cyclic(int g_a, int dims[])
{
Integer aa, ndim;
Integer _ga_dims[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(dims,_ga_dims, ndim);
wnga_set_block_cyclic(aa, _ga_dims);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60ab7
testq %rax, %rax
jle 0x8e752
movslq (%r14), %rcx
movq %rcx, -0x8(%rsp,%rax,8)
addq $0x4, %r14
decq %rax
jne 0x8e741
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x60ad2
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Get_proc_index | void GA_Get_proc_index(int g_a, int iproc, int index[])
{
Integer aa, proc, ndim;
Integer _ga_work[MAXDIM];
aa = (Integer)g_a;
proc = (Integer)iproc;
ndim = wnga_get_dimension(aa);
wnga_get_proc_index(aa, proc, _ga_work);
COPYF2C(_ga_work,index, ndim);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movslq %edi, %r12
movslq %esi, %r13
movq %r12, %rdi
callq 0x60ab7
movq %rax, %r14
movq %rsp, %r15
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x6944f
testq %r14, %r14
jle 0x8e939
movl (%r15), %eax
movl %eax, -0x4(%rbx,%r14,4)
addq $0x8, %r15
decq %r14
jne 0x8e928
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_tiled_proc_grid64 | void NGA_Set_tiled_proc_grid64(int g_a, int64_t block[], int64_t proc_grid[])
{
Integer aa, ndim;
Integer _block[MAXDIM];
Integer _proc_grid[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(block,_block, ndim);
COPYC2F(proc_grid, _proc_grid, ndim);
wnga_set_tiled_proc_grid(aa, _block, _proc_grid);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %r15
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60ab7
testq %rax, %rax
jle 0x8edd0
movq %rax, %rcx
movq (%r15), %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x8, %r15
decq %rcx
jne 0x8edbf
testq %rax, %rax
jle 0x8ede6
movq (%r14), %rcx
movq %rcx, -0x8(%rsp,%rax,8)
addq $0x8, %r14
decq %rax
jne 0x8edd5
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x60d70
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_tiled_irreg_proc_grid | void NGA_Set_tiled_irreg_proc_grid(int g_a, int mapc[], int nblocks[],
int proc_grid[])
{
Integer aa, ndim;
Integer *_ga_map_capi;
Integer _nblocks[MAXDIM];
Integer _proc_grid[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
_ga_map_capi = copy_map(nblocks, (int)ndim, mapc);
COPYC2F(nblocks,_nblocks, ndim);
COPYC2F(proc_grid, _proc_grid, ndim);
wnga_set_tiled_irreg_proc_grid(aa, _ga_map_capi, _nblocks, _proc_grid);
free(_ga_map_capi);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60ab7
movq %rax, %r12
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x8da95
movq %rax, %r15
testq %r12, %r12
jle 0x8eee9
movq %r12, %rax
movslq (%r13), %rcx
movq %rcx, 0x38(%rsp,%rax,8)
addq $0x4, %r13
decq %rax
jne 0x8eed7
testq %r12, %r12
jle 0x8eeff
movslq (%r14), %rax
movq %rax, -0x8(%rsp,%r12,8)
addq $0x4, %r14
decq %r12
jne 0x8eeee
leaq 0x40(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x60ee7
movq %r15, %rdi
callq 0x3330
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Access_block64 | void NGA_Access_block64(int g_a, int64_t idx, void *ptr, int64_t ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer iblock = (Integer)idx;
Integer _ga_work[MAXDIM];
wnga_access_block_ptr(a,iblock,ptr,_ga_work);
COPYF2C_64(_ga_work,ld, ndim-1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movslq %edi, %rbp
movq %rbp, %rdi
callq 0x65319
movq %rax, %r14
movq %rsp, %r15
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x6c674
cmpq $0x2, %r14
jl 0x91449
movq (%r15), %rax
movq %rax, -0x10(%rbx,%r14,8)
decq %r14
addq $0x8, %r15
cmpq $0x1, %r14
jne 0x91434
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Access_block_grid64 | void NGA_Access_block_grid64(int g_a, int64_t index[], void *ptr, int64_t ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_work[MAXDIM];
COPYC2F(index, _ga_lo, ndim);
wnga_access_block_grid_ptr(a,_ga_lo,ptr,_ga_work);
COPYF2C_64(_ga_work,ld, ndim-1);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movslq %edi, %r12
movq %r12, %rdi
callq 0x65319
movq %rax, %r14
testq %rax, %rax
jle 0x9151d
movq %r14, %rax
movq (%r13), %rcx
movq %rcx, -0x8(%rsp,%rax,8)
addq $0x8, %r13
decq %rax
jne 0x9150b
movq %rsp, %rsi
leaq 0x40(%rsp), %r13
movq %r12, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq 0x6bdea
cmpq $0x2, %r14
jl 0x9154f
movq (%r13), %rax
movq %rax, -0x10(%rbx,%r14,8)
decq %r14
addq $0x8, %r13
cmpq $0x1, %r14
jne 0x91539
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Access_ghost_element | void NGA_Access_ghost_element(int g_a, void *ptr, int subscript[], int ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _subscript[MAXDIM];
Integer _ld[MAXDIM];
COPYINDEX_C2F(subscript, _subscript, ndim);
COPYINDEX_C2F(ld, _ld, ndim-1);
wnga_access_ghost_element_ptr(a, ptr, _subscript, _ld);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movslq %edi, %r14
movq %r14, %rdi
callq 0x65319
testq %rax, %rax
jle 0x9170f
movq %rax, %rcx
movslq (%r12), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x4, %r12
decq %rcx
jne 0x916fa
cmpq $0x2, %rax
jl 0x9172d
movslq (%r15), %rcx
incq %rcx
movq %rcx, -0x10(%rsp,%rax,8)
decq %rax
addq $0x4, %r15
cmpq $0x1, %rax
jne 0x91715
leaq 0x40(%rsp), %rdx
movq %rsp, %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x78de7
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Locate_nnodes | int NGA_Locate_nnodes(int g_a, int lo[], int hi[])
{
/* logical st; */
Integer a=(Integer)g_a, np;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo,ndim);
COPYINDEX_C2F(hi,_ga_hi,ndim);
/* st = wnga_locate_nnodes(a, _ga_lo, _ga_hi, &np); */
(void)wnga_locate_nnodes(a, _ga_lo, _ga_hi, &np);
return (int)np;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rsi, %r15
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x65319
testq %rax, %rax
jle 0x91a71
movq %rax, %rcx
movslq (%r15), %rdx
incq %rdx
movq %rdx, 0x48(%rsp,%rcx,8)
addq $0x4, %r15
decq %rcx
jne 0x91a5d
testq %rax, %rax
jle 0x91a8a
movslq (%r14), %rcx
incq %rcx
movq %rcx, 0x8(%rsp,%rax,8)
addq $0x4, %r14
decq %rax
jne 0x91a76
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rcx
callq 0x66bcc
movl (%r14), %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Scatter | void NGA_Scatter(int g_a, void *v, int* subsArray[], int n)
{
int idx, i;
Integer a = (Integer)g_a;
Integer nv = (Integer)n;
#ifndef USE_GATSCAT_NEW
Integer ndim = wnga_ndim(a);
Integer *_subs_array;
_subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
for(idx=0; idx<n; idx++)
for(i=0; i<ndim; i++)
_subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx][i] + 1;
wnga_scatter(a, v, _subs_array, 0, nv);
free(_subs_array);
#else
wnga_scatter(a, v, subsArray, 1, nv);
#endif
} | movslq %edi, %rdi
movslq %ecx, %r8
movl $0x1, %ecx
jmp 0x74e5d
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Gather_flat | void NGA_Gather_flat(int g_a, void *v, int subsArray[], int n)
{
int idx, i;
Integer a = (Integer)g_a;
Integer nv = (Integer)n;
Integer ndim = wnga_ndim(a);
Integer *_subs_array;
_subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
/* adjust the indices for fortran interface */
for(idx=0; idx<n; idx++)
for(i=0; i<ndim; i++)
_subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx*ndim+i] + 1;
wnga_gather(a, v, _subs_array, 0, nv);
free(_subs_array);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movslq %edi, %r14
movq %r14, %rdi
callq 0x65319
movq %rax, %r13
imull %ebp, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x33b0
movq %rax, %r12
testq %rax, %rax
jne 0x9284b
leaq 0x28785(%rip), %rdi # 0xbafc9
xorl %esi, %esi
callq 0x18f07
testl %ebp, %ebp
jle 0x92896
movl %ebp, %eax
movq %r12, %rcx
addq $-0x8, %rcx
leaq (,%r13,8), %rdx
leaq (,%r13,4), %rsi
xorl %edi, %edi
testq %r13, %r13
jle 0x92888
movq %r15, %r8
movq %r13, %r9
movslq (%r8), %r10
incq %r10
movq %r10, (%rcx,%r9,8)
addq $0x4, %r8
decq %r9
jne 0x92875
incq %rdi
addq %rdx, %rcx
addq %rsi, %r15
cmpq %rax, %rdi
jne 0x9286a
movslq %ebp, %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x74d66
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3330
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Gather_flat64 | void NGA_Gather_flat64(int g_a, void *v, int64_t subsArray[], int64_t n)
{
int idx, i;
Integer a = (Integer)g_a;
Integer nv = (Integer)n;
Integer ndim = wnga_ndim(a);
Integer *_subs_array;
_subs_array = (Integer *)malloc((int)ndim* n * sizeof(Integer));
if(_subs_array == NULL) GA_Error("Memory allocation failed.", 0);
/* adjust the indices for fortran interface */
for(idx=0; idx<n; idx++)
for(i=0; i<ndim; i++)
_subs_array[idx*ndim+(ndim-i-1)] = subsArray[idx*ndim+i] + 1;
wnga_gather(a, v, _subs_array, 0, nv);
free(_subs_array);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movslq %edi, %r15
movq %r15, %rdi
callq 0x65319
movq %rax, %rbp
movslq %ebp, %rdi
imulq %rbx, %rdi
shlq $0x3, %rdi
callq 0x33b0
movq %rax, %r13
testq %rax, %rax
jne 0x92917
leaq 0x286b9(%rip), %rdi # 0xbafc9
xorl %esi, %esi
callq 0x18f07
testq %rbx, %rbx
jle 0x92959
movq %r13, %rax
addq $-0x8, %rax
leaq (,%rbp,8), %rcx
xorl %edx, %edx
testq %rbp, %rbp
jle 0x9294b
movq %r12, %rsi
movq %rbp, %rdi
movq (%rsi), %r8
incq %r8
movq %r8, (%rax,%rdi,8)
addq $0x8, %rsi
decq %rdi
jne 0x92938
incq %rdx
addq %rcx, %rax
addq %rcx, %r12
cmpq %rbx, %rdx
jne 0x9292d
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x74d66
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3330
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Sgemm64_c | void GA_Sgemm64_c(char ta, char tb, int64_t m, int64_t n, int64_t k,
float alpha, int g_a, int g_b,
float beta, int g_c )
{
Integer G_a = g_a;
Integer G_b = g_b;
Integer G_c = g_c;
Integer ailo = 1;
Integer aihi = m;
Integer ajlo = 1;
Integer ajhi = k;
Integer bilo = 1;
Integer bihi = k;
Integer bjlo = 1;
Integer bjhi = n;
Integer cilo = 1;
Integer cihi = m;
Integer cjlo = 1;
Integer cjhi = n;
pnga_matmul(&ta, &tb, (float*)&alpha, (float*)&beta,
G_a, ailo, aihi, ajlo, ajhi,
G_b, bilo, bihi, bjlo, bjhi,
G_c, cilo, cihi, cjlo, cjhi);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r10
movq %rcx, %r11
movq %rdx, %rax
movslq 0x40(%rsp), %r15
movslq 0x48(%rsp), %r13
leaq 0x7(%rsp), %rbx
movb %dil, (%rbx)
leaq 0x6(%rsp), %r14
movb %sil, (%r14)
leaq 0xc(%rsp), %rdx
movss %xmm0, (%rdx)
leaq 0x8(%rsp), %rcx
movss %xmm1, (%rcx)
movslq %r9d, %r8
subq $0x8, %rsp
movl $0x1, %r12d
movl $0x1, %r9d
movq %rbx, %rdi
movq %r14, %rsi
pushq %r11
pushq %r12
pushq %rax
pushq %r12
pushq %r13
pushq %r11
pushq %r12
pushq %r10
pushq %r12
pushq %r15
pushq %r10
pushq %r12
pushq %rax
callq 0x1ea5b
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Matmul_patch | void GA_Matmul_patch(char transa, char transb, void* alpha, void *beta,
int g_a, int ailo, int aihi, int ajlo, int ajhi,
int g_b, int bilo, int bihi, int bjlo, int bjhi,
int g_c, int cilo, int cihi, int cjlo, int cjhi)
{
Integer Ig_a = g_a;
Integer Ig_b = g_b;
Integer Ig_c = g_c;
#if 0
Integer alo[2], ahi[2];
Integer blo[2], bhi[2];
Integer clo[2], chi[2];
alo[0]=ailo+1; ahi[0]=aihi+1; alo[1]=ajlo+1; ahi[1]=ajhi+1;
blo[0]=bilo+1; bhi[0]=bihi+1; blo[1]=bjlo+1; bhi[1]=bjhi+1;
clo[0]=cilo+1; chi[0]=cihi+1; clo[1]=cjlo+1; chi[1]=cjhi+1;
pnga_matmul_patch(transa, transb, alpha, beta, g_a, alo, ahi,
g_b, blo, bhi, g_c, clo, chi);
#else
Integer Iailo=ailo+1, Iaihi=aihi+1, Iajlo=ajlo+1, Iajhi=ajhi+1;
Integer Ibilo=bilo+1, Ibihi=bihi+1, Ibjlo=bjlo+1, Ibjhi=bjhi+1;
Integer Icilo=cilo+1, Icihi=cihi+1, Icjlo=cjlo+1, Icjhi=cjhi+1;
if(pnga_is_mirrored(Ig_a))
wnga_matmul_mirrored(&transa, &transb, (void*)alpha, (void*)beta,
Ig_a, Iailo, Iaihi, Iajlo, Iajhi,
Ig_b, Ibilo, Ibihi, Ibjlo, Ibjhi,
Ig_c, Icilo, Icihi, Icjlo, Icjhi);
else {
gai_matmul_patch_flag(SET);
wnga_matmul(&transa, &transb, (void*)alpha, (void*)beta,
Ig_a, Iailo, Iaihi, Iajlo, Iajhi,
Ig_b, Ibilo, Ibihi, Ibjlo, Ibjhi,
Ig_c, Icilo, Icihi, Icjlo, Icjhi);
gai_matmul_patch_flag(UNSET);
}
#endif
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl 0x100(%rsp), %eax
movl 0xf8(%rsp), %ecx
movl 0xf0(%rsp), %edx
movl 0xe8(%rsp), %r10d
movl 0xd8(%rsp), %r11d
movl 0xd0(%rsp), %ebx
movl 0xc8(%rsp), %ebp
movl 0xc0(%rsp), %r14d
movl 0xb0(%rsp), %r12d
movb %dil, 0xf(%rsp)
movl 0xa8(%rsp), %edi
movb %sil, 0xe(%rsp)
movl 0xa0(%rsp), %esi
movslq %r8d, %r15
incl %r9d
movslq %r9d, %r8
movq %r8, 0x10(%rsp)
incl %esi
movslq %esi, %rsi
movq %rsi, 0x60(%rsp)
incl %edi
movslq %edi, %rsi
movq %rsi, 0x58(%rsp)
incl %r12d
movslq %r12d, %rsi
movq %rsi, 0x50(%rsp)
incl %r14d
movslq %r14d, %rsi
movq %rsi, 0x48(%rsp)
incl %ebp
movslq %ebp, %rsi
movq %rsi, 0x30(%rsp)
incl %ebx
movslq %ebx, %rsi
movq %rsi, 0x28(%rsp)
incl %r11d
movslq %r11d, %rsi
movq %rsi, 0x18(%rsp)
incl %r10d
movslq %r10d, %r13
incl %edx
movslq %edx, %rbx
incl %ecx
movslq %ecx, %r14
incl %eax
movslq %eax, %r12
movslq 0xb8(%rsp), %rax
movq %rax, 0x20(%rsp)
movslq 0xe0(%rsp), %rbp
movq %r15, %rdi
callq 0x5de62
testq %rax, %rax
je 0x932b8
subq $0x8, %rsp
leaq 0x17(%rsp), %rdi
leaq 0x16(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq %r15, %r8
movq 0x18(%rsp), %r9
pushq %r12
pushq %r14
pushq %rbx
pushq %r13
pushq %rbp
pushq 0x48(%rsp)
pushq 0x60(%rsp)
pushq 0x70(%rsp)
pushq 0x90(%rsp)
pushq 0x70(%rsp)
pushq 0xa8(%rsp)
pushq 0xb8(%rsp)
pushq 0xc8(%rsp)
callq 0x2252e
addq $0x70, %rsp
jmp 0x93326
movl $0x1, %edi
callq 0x1ea54
subq $0x8, %rsp
leaq 0x17(%rsp), %rdi
leaq 0x16(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq %r15, %r8
movq 0x18(%rsp), %r9
pushq %r12
pushq %r14
pushq %rbx
pushq %r13
pushq %rbp
pushq 0x48(%rsp)
pushq 0x60(%rsp)
pushq 0x70(%rsp)
pushq 0x90(%rsp)
pushq 0x70(%rsp)
pushq 0xa8(%rsp)
pushq 0xb8(%rsp)
pushq 0xc8(%rsp)
callq 0x1ea5b
addq $0x70, %rsp
xorl %edi, %edi
callq 0x1ea54
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Matmul_patch | void NGA_Matmul_patch(char transa, char transb, void* alpha, void *beta,
int g_a, int alo[], int ahi[],
int g_b, int blo[], int bhi[],
int g_c, int clo[], int chi[])
{
Integer a=(Integer)g_a;
Integer andim = wnga_ndim(a);
Integer b=(Integer)g_b;
Integer bndim = wnga_ndim(b);
Integer c=(Integer)g_c;
Integer cndim = wnga_ndim(c);
Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
COPYINDEX_C2F(alo,_ga_alo, andim);
COPYINDEX_C2F(ahi,_ga_ahi, andim);
COPYINDEX_C2F(blo,_ga_blo, bndim);
COPYINDEX_C2F(bhi,_ga_bhi, bndim);
COPYINDEX_C2F(clo,_ga_clo, cndim);
COPYINDEX_C2F(chi,_ga_chi, cndim);
wnga_matmul_patch(&transb, &transa, alpha, beta,
b, _ga_blo, _ga_bhi,
a, _ga_alo, _ga_ahi,
c, _ga_clo, _ga_chi);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r9, %r12
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movslq 0x1f0(%rsp), %r14
movslq 0x1d8(%rsp), %r13
movb %dil, 0xf(%rsp)
movb %sil, 0xe(%rsp)
movslq %r8d, %rbx
movq %rbx, %rdi
callq 0x65319
movq %rax, %r15
movq %r13, %rdi
callq 0x65319
movq %rax, %rbp
movq %r14, %rdi
callq 0x65319
testq %r15, %r15
jle 0x93580
movq %r15, %rcx
movslq (%r12), %rdx
incq %rdx
movq %rdx, 0x158(%rsp,%rcx,8)
addq $0x4, %r12
decq %rcx
jne 0x93568
testq %r15, %r15
jle 0x935a4
movq 0x1d0(%rsp), %rcx
movslq (%rcx), %rdx
incq %rdx
movq %rdx, 0x118(%rsp,%r15,8)
addq $0x4, %rcx
decq %r15
jne 0x9358d
testq %rbp, %rbp
jle 0x935cb
movq 0x1e0(%rsp), %rcx
movq %rbp, %rdx
movslq (%rcx), %rsi
incq %rsi
movq %rsi, 0xd8(%rsp,%rdx,8)
addq $0x4, %rcx
decq %rdx
jne 0x935b4
testq %rbp, %rbp
jle 0x935ef
movq 0x1e8(%rsp), %rcx
movslq (%rcx), %rdx
incq %rdx
movq %rdx, 0x98(%rsp,%rbp,8)
addq $0x4, %rcx
decq %rbp
jne 0x935d8
testq %rax, %rax
jle 0x93613
movq 0x1f8(%rsp), %rcx
movq %rax, %rdx
movslq (%rcx), %rsi
incq %rsi
movq %rsi, 0x58(%rsp,%rdx,8)
addq $0x4, %rcx
decq %rdx
jne 0x935ff
testq %rax, %rax
jle 0x93634
movq 0x200(%rsp), %rcx
movslq (%rcx), %rdx
incq %rdx
movq %rdx, 0x18(%rsp,%rax,8)
addq $0x4, %rcx
decq %rax
jne 0x93620
subq $0x8, %rsp
leaq 0x28(%rsp), %rax
leaq 0x68(%rsp), %r10
leaq 0x128(%rsp), %r11
leaq 0x168(%rsp), %r15
leaq 0xa8(%rsp), %r12
leaq 0x16(%rsp), %rdi
leaq 0x17(%rsp), %rsi
leaq 0xe8(%rsp), %r9
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %r13, %r8
pushq %rax
pushq %r10
pushq %r14
pushq %r11
pushq %r15
pushq %rbx
pushq %r12
callq 0x25244
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Cdot_patch | SingleComplex NGA_Cdot_patch(int g_a, char t_a, int alo[], int ahi[],
int g_b, char t_b, int blo[], int bhi[])
{
SingleComplex res;
Integer a=(Integer)g_a;
Integer andim = wnga_ndim(a);
Integer b=(Integer)g_b;
Integer bndim = wnga_ndim(b);
Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
COPYINDEX_C2F(alo,_ga_alo, andim);
COPYINDEX_C2F(ahi,_ga_ahi, andim);
COPYINDEX_C2F(blo,_ga_blo, bndim);
COPYINDEX_C2F(bhi,_ga_bhi, bndim);
wnga_dot_patch(a, &t_a, _ga_alo, _ga_ahi,
b, &t_b, _ga_blo, _ga_bhi, &res);
return res;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r13
movb %sil, 0x7(%rsp)
movb %r9b, 0x6(%rsp)
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x65319
movq %rax, %r12
movslq %ebp, %r14
movq %r14, %rdi
callq 0x65319
testq %r12, %r12
jle 0x94126
movq %r12, %rcx
movslq (%r13), %rdx
incq %rdx
movq %rdx, 0xc8(%rsp,%rcx,8)
addq $0x4, %r13
decq %rcx
jne 0x9410e
testq %r12, %r12
jle 0x94142
movslq (%r15), %rcx
incq %rcx
movq %rcx, 0x88(%rsp,%r12,8)
addq $0x4, %r15
decq %r12
jne 0x9412b
testq %rax, %rax
jle 0x94166
movq 0x140(%rsp), %rcx
movq %rax, %rdx
movslq (%rcx), %rsi
incq %rsi
movq %rsi, 0x48(%rsp,%rdx,8)
addq $0x4, %rcx
decq %rdx
jne 0x94152
testq %rax, %rax
jle 0x94187
movq 0x148(%rsp), %rcx
movslq (%rcx), %rdx
incq %rdx
movq %rdx, 0x8(%rsp,%rax,8)
addq $0x4, %rcx
decq %rax
jne 0x94173
subq $0x8, %rsp
leaq 0x10(%rsp), %r15
leaq 0x18(%rsp), %rax
leaq 0x58(%rsp), %r10
leaq 0xf(%rsp), %rsi
leaq 0xd8(%rsp), %rdx
leaq 0x98(%rsp), %rcx
leaq 0xe(%rsp), %r9
movq %rbx, %rdi
movq %r14, %r8
pushq %r15
pushq %rax
pushq %r10
callq 0x13b13
addq $0x20, %rsp
movsd (%r15), %xmm0
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Add_patch64 | void NGA_Add_patch64(void * alpha, int g_a, int64_t alo[], int64_t ahi[],
void * beta, int g_b, int64_t blo[], int64_t bhi[],
int g_c, int64_t clo[], int64_t chi[])
{
Integer a=(Integer)g_a;
Integer andim = wnga_ndim(a);
Integer b=(Integer)g_b;
Integer bndim = wnga_ndim(b);
Integer c=(Integer)g_c;
Integer cndim = wnga_ndim(c);
Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
COPYINDEX_C2F(alo,_ga_alo, andim);
COPYINDEX_C2F(ahi,_ga_ahi, andim);
COPYINDEX_C2F(blo,_ga_blo, bndim);
COPYINDEX_C2F(bhi,_ga_bhi, bndim);
COPYINDEX_C2F(clo,_ga_clo, cndim);
COPYINDEX_C2F(chi,_ga_chi, cndim);
wnga_add_patch(alpha, a, _ga_alo, _ga_ahi, beta, b, _ga_blo, _ga_bhi,
c, _ga_clo, _ga_chi);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movl %r9d, %ebp
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, 0x8(%rsp)
movslq 0x1e0(%rsp), %r12
movslq %esi, %rdi
movq %rdi, (%rsp)
callq 0x65319
movq %rax, %r15
movslq %ebp, %r13
movq %r13, %rdi
callq 0x65319
movq %rax, %rbp
movq %r12, 0x18(%rsp)
movq %r12, %rdi
callq 0x65319
testq %r15, %r15
jle 0x94f34
movq %r15, %rcx
movq (%rbx), %rdx
incq %rdx
movq %rdx, 0x158(%rsp,%rcx,8)
addq $0x8, %rbx
decq %rcx
jne 0x94f1d
testq %r15, %r15
jle 0x94f50
movq (%r14), %rcx
incq %rcx
movq %rcx, 0x118(%rsp,%r15,8)
addq $0x8, %r14
decq %r15
jne 0x94f39
testq %rbp, %rbp
jle 0x94f77
movq 0x1d0(%rsp), %rcx
movq %rbp, %rdx
movq (%rcx), %rsi
incq %rsi
movq %rsi, 0xd8(%rsp,%rdx,8)
addq $0x8, %rcx
decq %rdx
jne 0x94f60
testq %rbp, %rbp
jle 0x94f9b
movq 0x1d8(%rsp), %rcx
movq (%rcx), %rdx
incq %rdx
movq %rdx, 0x98(%rsp,%rbp,8)
addq $0x8, %rcx
decq %rbp
jne 0x94f84
testq %rax, %rax
jle 0x94fbf
movq 0x1e8(%rsp), %rcx
movq %rax, %rdx
movq (%rcx), %rsi
incq %rsi
movq %rsi, 0x58(%rsp,%rdx,8)
addq $0x8, %rcx
decq %rdx
jne 0x94fab
testq %rax, %rax
jle 0x94fe0
movq 0x1f0(%rsp), %rcx
movq (%rcx), %rdx
incq %rdx
movq %rdx, 0x18(%rsp,%rax,8)
addq $0x8, %rcx
decq %rax
jne 0x94fcc
subq $0x8, %rsp
leaq 0x28(%rsp), %rax
leaq 0x68(%rsp), %r10
leaq 0xa8(%rsp), %r11
leaq 0xe8(%rsp), %rbx
leaq 0x168(%rsp), %rdx
leaq 0x128(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %r8
movq %r13, %r9
pushq %rax
pushq %r10
pushq 0x30(%rsp)
pushq %r11
pushq %rbx
callq 0x15cbe
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Lu_solve | void GA_Lu_solve(char tran, int g_a, int g_b)
{
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer t;
if(tran == 't' || tran == 'T') t = 1;
else t = 0;
wnga_lu_solve_alt(t, a, b);
} | andb $-0x21, %dil
xorl %eax, %eax
cmpb $0x54, %dil
sete %al
movslq %edx, %rdx
movslq %esi, %rsi
movq %rax, %rdi
jmp 0x2a344
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Step_max_patch64 | void GA_Step_max_patch64(int g_a, int64_t alo[], int64_t ahi[],
int g_b, int64_t blo[], int64_t bhi[], void *step)
{
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer ndim = wnga_ndim(a);
Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
COPYINDEX_C2F(alo,_ga_alo, ndim);
COPYINDEX_C2F(ahi,_ga_ahi, ndim);
COPYINDEX_C2F(blo,_ga_blo, ndim);
COPYINDEX_C2F(bhi,_ga_bhi, ndim);
wnga_step_max_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, step);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x65319
testq %rax, %rax
jle 0x958e1
movq %rax, %rcx
movq (%r13), %rdx
incq %rdx
movq %rdx, 0xc8(%rsp,%rcx,8)
addq $0x8, %r13
decq %rcx
jne 0x958c9
testq %rax, %rax
jle 0x95901
movq %rax, %rcx
movq (%r12), %rdx
incq %rdx
movq %rdx, 0x88(%rsp,%rcx,8)
addq $0x8, %r12
decq %rcx
jne 0x958e9
testq %rax, %rax
jle 0x9591d
movq %rax, %rcx
movq (%r15), %rdx
incq %rdx
movq %rdx, 0x48(%rsp,%rcx,8)
addq $0x8, %r15
decq %rcx
jne 0x95909
movq 0x140(%rsp), %rdx
testq %rax, %rax
jle 0x9593e
movq (%r14), %rcx
incq %rcx
movq %rcx, 0x8(%rsp,%rax,8)
addq $0x8, %r14
decq %rax
jne 0x9592a
movslq %ebp, %rcx
movq %rdx, (%rsp)
leaq 0xd0(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0x50(%rsp), %r8
leaq 0x10(%rsp), %r9
movq %rbx, %rdi
callq 0xd4af
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Recip_patch64 | void GA_Recip_patch64(int g_a, int64_t *lo, int64_t *hi)
{
Integer a = (Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ndim);
wnga_recip_patch(a,_ga_lo, _ga_hi);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %r15
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x65319
testq %rax, %rax
jle 0x95c37
movq %rax, %rcx
movq (%r15), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x8, %r15
decq %rcx
jne 0x95c23
testq %rax, %rax
jle 0x95c50
movq (%r14), %rcx
incq %rcx
movq %rcx, -0x8(%rsp,%rax,8)
addq $0x8, %r14
decq %rax
jne 0x95c3c
leaq 0x40(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xae7a
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Elem_minimum_patch | void GA_Elem_minimum_patch(int g_a, int alo[], int ahi[],
int g_b, int blo[], int bhi[],
int g_c, int clo[], int chi[])
{
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer c = (Integer)g_c;
Integer andim = wnga_ndim(a);
Integer bndim = wnga_ndim(b);
Integer cndim = wnga_ndim(c);
Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
COPYINDEX_C2F(alo,_ga_alo, andim);
COPYINDEX_C2F(ahi,_ga_ahi, andim);
COPYINDEX_C2F(blo,_ga_blo, bndim);
COPYINDEX_C2F(bhi,_ga_bhi, bndim);
COPYINDEX_C2F(clo,_ga_clo, cndim);
COPYINDEX_C2F(chi,_ga_chi, cndim);
wnga_elem_minimum_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %r9, %r12
movq %r8, %rbp
movq %rdx, %rbx
movq %rsi, %r15
movslq 0x1d0(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq %edi, %rdi
movslq %ecx, %r13
movq %rdi, 0x10(%rsp)
callq 0x65319
movq %rax, %r14
movq %r13, 0x18(%rsp)
movq %r13, %rdi
callq 0x65319
movq %rax, %r13
movq 0x8(%rsp), %rdi
callq 0x65319
testq %r14, %r14
jle 0x9655f
movq %r14, %rcx
movslq (%r15), %rdx
incq %rdx
movq %rdx, 0x158(%rsp,%rcx,8)
addq $0x4, %r15
decq %rcx
jne 0x96548
testq %r14, %r14
jle 0x9657b
movslq (%rbx), %rcx
incq %rcx
movq %rcx, 0x118(%rsp,%r14,8)
addq $0x4, %rbx
decq %r14
jne 0x96564
testq %r13, %r13
jle 0x9659b
movq %r13, %rcx
movslq (%rbp), %rdx
incq %rdx
movq %rdx, 0xd8(%rsp,%rcx,8)
addq $0x4, %rbp
decq %rcx
jne 0x96583
testq %r13, %r13
jle 0x965b8
movslq (%r12), %rcx
incq %rcx
movq %rcx, 0x98(%rsp,%r13,8)
addq $0x4, %r12
decq %r13
jne 0x965a0
testq %rax, %rax
jle 0x965dc
movq 0x1d8(%rsp), %rcx
movq %rax, %rdx
movslq (%rcx), %rsi
incq %rsi
movq %rsi, 0x58(%rsp,%rdx,8)
addq $0x4, %rcx
decq %rdx
jne 0x965c8
testq %rax, %rax
jle 0x965fd
movq 0x1e0(%rsp), %rcx
movslq (%rcx), %rdx
incq %rdx
movq %rdx, 0x18(%rsp,%rax,8)
addq $0x4, %rcx
decq %rax
jne 0x965e9
subq $0x8, %rsp
leaq 0x28(%rsp), %rax
leaq 0x68(%rsp), %r10
leaq 0x168(%rsp), %rsi
leaq 0x128(%rsp), %rdx
leaq 0xe8(%rsp), %r8
leaq 0xa8(%rsp), %r9
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
pushq %rax
pushq %r10
pushq 0x20(%rsp)
callq 0xc282
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Median_patch | void GA_Median_patch(int g_a, int *alo, int *ahi,
int g_b, int *blo, int *bhi,
int g_c, int *clo, int *chi,
int g_m, int *mlo, int *mhi){
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer c = (Integer)g_c;
Integer m = (Integer )g_m;
Integer andim = wnga_ndim(a);
Integer bndim = wnga_ndim(b);
Integer cndim = wnga_ndim(c);
Integer mndim = wnga_ndim(m);
Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
Integer _ga_mlo[MAXDIM], _ga_mhi[MAXDIM];
COPYINDEX_C2F(alo,_ga_alo, andim);
COPYINDEX_C2F(ahi,_ga_ahi, andim);
COPYINDEX_C2F(blo,_ga_blo, bndim);
COPYINDEX_C2F(bhi,_ga_bhi, bndim);
COPYINDEX_C2F(clo,_ga_clo, cndim);
COPYINDEX_C2F(chi,_ga_chi, cndim);
COPYINDEX_C2F(mlo,_ga_mlo, mndim);
COPYINDEX_C2F(mhi,_ga_mhi, mndim);
wnga_median_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi, m, _ga_mlo, _ga_mhi);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %r9, %rbp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r13
movslq 0x278(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x260(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq %edi, %rdi
movslq %ecx, %rbx
movq %rdi, 0x20(%rsp)
callq 0x65319
movq %rax, %r12
movq %rbx, 0x28(%rsp)
movq %rbx, %rdi
callq 0x65319
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x65319
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x65319
testq %r12, %r12
jle 0x968b8
movq %r12, %rcx
movslq (%r13), %rdx
incq %rdx
movq %rdx, 0x1e8(%rsp,%rcx,8)
addq $0x4, %r13
decq %rcx
jne 0x968a0
testq %r12, %r12
jle 0x968d4
movslq (%r15), %rcx
incq %rcx
movq %rcx, 0x1a8(%rsp,%r12,8)
addq $0x4, %r15
decq %r12
jne 0x968bd
testq %rbx, %rbx
movq 0x18(%rsp), %rdi
jle 0x968f8
movq %rbx, %rcx
movslq (%r14), %rdx
incq %rdx
movq %rdx, 0x168(%rsp,%rcx,8)
addq $0x4, %r14
decq %rcx
jne 0x968e1
testq %rbx, %rbx
jle 0x96915
movslq (%rbp), %rcx
incq %rcx
movq %rcx, 0x128(%rsp,%rbx,8)
addq $0x4, %rbp
decq %rbx
jne 0x968fd
testq %rdi, %rdi
jle 0x9693c
movq 0x268(%rsp), %rcx
movq %rdi, %rdx
movslq (%rcx), %rsi
incq %rsi
movq %rsi, 0xe8(%rsp,%rdx,8)
addq $0x4, %rcx
decq %rdx
jne 0x96925
testq %rdi, %rdi
jle 0x96960
movq 0x270(%rsp), %rcx
movslq (%rcx), %rdx
incq %rdx
movq %rdx, 0xa8(%rsp,%rdi,8)
addq $0x4, %rcx
decq %rdi
jne 0x96949
testq %rax, %rax
jle 0x96984
movq 0x280(%rsp), %rcx
movq %rax, %rdx
movslq (%rcx), %rsi
incq %rsi
movq %rsi, 0x68(%rsp,%rdx,8)
addq $0x4, %rcx
decq %rdx
jne 0x96970
testq %rax, %rax
jle 0x969a5
movq 0x288(%rsp), %rcx
movslq (%rcx), %rdx
incq %rdx
movq %rdx, 0x28(%rsp,%rax,8)
addq $0x4, %rcx
decq %rax
jne 0x96991
leaq 0x30(%rsp), %rax
leaq 0x70(%rsp), %r10
leaq 0xb0(%rsp), %r11
leaq 0xf0(%rsp), %rbx
leaq 0x1f0(%rsp), %rsi
leaq 0x1b0(%rsp), %rdx
leaq 0x170(%rsp), %r8
leaq 0x130(%rsp), %r9
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rcx
pushq %rax
pushq %r10
pushq 0x18(%rsp)
pushq %r11
pushq %rbx
pushq 0x38(%rsp)
callq 0x25a0c
addq $0x258, %rsp # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Sprs_array_row_distribution | void NGA_Sprs_array_row_distribution(int s_a, int iproc, int *lo, int *hi)
{
Integer sa = (Integer)s_a;
Integer ip = (Integer)iproc;
Integer ilo, ihi;
wnga_sprs_array_row_distribution(sa,ip,&ilo,&ihi);
*lo = (int)ilo;
*hi = (int)ihi;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movslq %edi, %rdi
movslq %esi, %rsi
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdx
movq %r12, %rcx
callq 0x3c2ab
movl (%r15), %eax
movl %eax, (%r14)
movl (%r12), %eax
movl %eax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/capi.c |
ga_sort_permutation | void ga_sort_permutation(pn, index, base)
Integer *pn;
Integer *index;
Integer *base;
{
if (*pn < 2) return;
# undef SWAP
# define SWAP(a,b) { \
Integer ltmp; \
Integer itmp;\
long ia = a - base; \
long ib = b - base; \
ltmp=*a; *a=*b; *b=ltmp; \
itmp=index[ia]; index[ia]=index[ib]; index[ib] = itmp;\
}
INDEX_SORT(base,pn,SWAP);
} | movq (%rdi), %r8
cmpq $0x2, %r8
jl 0x98dc5
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rcx
shrq %rcx
leaq -0x8(,%r8,8), %rax
cmpq $0x1, %rcx
je 0x98d1b
leaq -0x8(%rdx), %rdi
leaq (%rdx,%r8,8), %r8
addq $-0x8, %r8
leaq (%rdi,%rcx,8), %r9
leaq (%r9,%rcx,8), %rbx
cmpq %r8, %rbx
ja 0x98d12
movq %rcx, %r10
addq %r10, %r10
cmpq %r8, %rbx
je 0x98cd9
leaq 0x8(%rbx), %r11
movq 0x8(%rbx), %r14
xorl %r15d, %r15d
cmpq (%rbx), %r14
setg %r15b
cmovleq %rbx, %r11
orq %r15, %r10
jmp 0x98cdc
movq %rbx, %r11
movq (%r9), %rbx
movq (%r11), %r14
cmpq %r14, %rbx
jge 0x98d12
movq %r11, %r15
subq %rdx, %r15
movq %r14, (%r9)
subq %rdx, %r9
movq %rbx, (%r11)
movq (%rsi,%r9), %rbx
movq (%rsi,%r15), %r14
movq %r14, (%rsi,%r9)
movq %rbx, (%rsi,%r15)
leaq (%r11,%r10,8), %rbx
movq %r11, %r9
cmpq %r8, %rbx
jbe 0x98cb6
decq %rcx
cmpq $0x1, %rcx
jne 0x98ca6
testq %rax, %rax
je 0x98dc0
leaq 0x8(%rdx), %rcx
cmpq $0x8, %rax
jl 0x98d9a
leaq (%rdx,%rax), %rdi
movl $0x1, %r8d
movq %rcx, %r11
movq %rdx, %r9
addq %r8, %r8
cmpq %rdi, %r11
je 0x98d61
leaq 0x8(%r11), %r10
movq 0x8(%r11), %rbx
xorl %r14d, %r14d
cmpq (%r11), %rbx
setg %r14b
cmovleq %r11, %r10
orq %r14, %r8
jmp 0x98d64
movq %r11, %r10
movq (%r9), %r11
movq (%r10), %rbx
cmpq %rbx, %r11
jge 0x98d9a
movq %r10, %r14
subq %rdx, %r14
movq %rbx, (%r9)
subq %rdx, %r9
movq %r11, (%r10)
movq (%rsi,%r9), %r11
movq (%rsi,%r14), %rbx
movq %rbx, (%rsi,%r9)
movq %r11, (%rsi,%r14)
leaq (%r10,%r8,8), %r11
movq %r10, %r9
cmpq %rdi, %r11
jbe 0x98d3e
movq (%rdx), %rdi
movq (%rdx,%rax), %r8
movq %r8, (%rdx)
movq %rdi, (%rdx,%rax)
movq (%rsi), %rdi
movq (%rsi,%rax), %r8
movq %r8, (%rsi)
movq %rdi, (%rsi,%rax)
addq $-0x8, %rax
jne 0x98d28
popq %rbx
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/hsort.scat.c |
ga_sort_gath | void ga_sort_gath(pn, i, j, base)
Integer *pn;
Integer *i;
Integer *j;
Integer *base;
{
if (*pn < 2) return;
# undef SWAP
# define SWAP(a,b) { \
Integer ltmp; \
long ia = a - base; \
long ib = b - base; \
ltmp=*a; *a=*b; *b=ltmp; \
ltmp=i[ia]; i[ia]=i[ib]; i[ib]=ltmp; \
ltmp=j[ia]; j[ia]=j[ib]; j[ib]=ltmp; \
}
INDEX_SORT(base,pn,SWAP);
} | movq (%rdi), %r9
cmpq $0x2, %r9
jl 0x99aa6
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rdi
shrq %rdi
leaq -0x8(,%r9,8), %rax
cmpq $0x1, %rdi
je 0x999dc
leaq -0x8(%rcx), %r8
leaq (%rcx,%r9,8), %r9
addq $-0x8, %r9
leaq (%r8,%rdi,8), %r10
leaq (%r10,%rdi,8), %r14
cmpq %r9, %r14
ja 0x999cf
movq %rdi, %r11
addq %r11, %r11
cmpq %r9, %r14
je 0x99986
leaq 0x8(%r14), %rbx
movq 0x8(%r14), %r15
xorl %r12d, %r12d
cmpq (%r14), %r15
setg %r12b
cmovleq %r14, %rbx
orq %r12, %r11
jmp 0x99989
movq %r14, %rbx
movq (%r10), %r14
movq (%rbx), %r15
cmpq %r15, %r14
jge 0x999cf
movq %rbx, %r12
subq %rcx, %r12
movq %r15, (%r10)
subq %rcx, %r10
movq %r14, (%rbx)
movq (%rsi,%r10), %r14
movq (%rsi,%r12), %r15
movq %r15, (%rsi,%r10)
movq %r14, (%rsi,%r12)
movq (%rdx,%r10), %r14
movq (%rdx,%r12), %r15
movq %r15, (%rdx,%r10)
movq %r14, (%rdx,%r12)
leaq (%rbx,%r11,8), %r14
movq %rbx, %r10
cmpq %r9, %r14
jbe 0x99963
decq %rdi
cmpq $0x1, %rdi
jne 0x99953
testq %rax, %rax
je 0x99a9f
leaq 0x8(%rcx), %rdi
cmpq $0x8, %rax
jl 0x99a6b
leaq (%rcx,%rax), %r8
movl $0x1, %r9d
movq %rdi, %rbx
movq %rcx, %r10
addq %r9, %r9
cmpq %r8, %rbx
je 0x99a22
leaq 0x8(%rbx), %r11
movq 0x8(%rbx), %r14
xorl %r15d, %r15d
cmpq (%rbx), %r14
setg %r15b
cmovleq %rbx, %r11
orq %r15, %r9
jmp 0x99a25
movq %rbx, %r11
movq (%r10), %rbx
movq (%r11), %r14
cmpq %r14, %rbx
jge 0x99a6b
movq %r11, %r15
subq %rcx, %r15
movq %r14, (%r10)
subq %rcx, %r10
movq %rbx, (%r11)
movq (%rsi,%r10), %rbx
movq (%rsi,%r15), %r14
movq %r14, (%rsi,%r10)
movq %rbx, (%rsi,%r15)
movq (%rdx,%r10), %rbx
movq (%rdx,%r15), %r14
movq %r14, (%rdx,%r10)
movq %rbx, (%rdx,%r15)
leaq (%r11,%r9,8), %rbx
movq %r11, %r10
cmpq %r8, %rbx
jbe 0x999ff
movq (%rcx), %r8
movq (%rcx,%rax), %r9
movq %r9, (%rcx)
movq %r8, (%rcx,%rax)
movq (%rsi), %r8
movq (%rsi,%rax), %r9
movq %r9, (%rsi)
movq %r8, (%rsi,%rax)
movq (%rdx), %r8
movq (%rdx,%rax), %r9
movq %r9, (%rdx)
movq %r8, (%rdx,%rax)
addq $-0x8, %rax
jne 0x999e9
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/global/src/hsort.scat.c |
nga_wait_internal | int nga_wait_internal(Integer *nbhandle){
gai_nbhdl_t *inbhandle = (gai_nbhdl_t *)nbhandle;
int index = inbhandle->ihdl_index;
int retval = 0;
int tag = inbhandle->ga_nbtag;
/* check if tags match. If they don't then this request was already completed
* so the handle can be used for another GA non-blocking call. Just return in
* this case */
if (tag == ga_ihdl_array[index].ga_nbtag) {
if (ga_ihdl_array[index].active == 0) {
printf("p[%ld] nga_wait_internal: GA NB handle %d inactive slot: %d tag: %d\n",
GAme,*((int*)inbhandle),index,tag);
}
ga_armcihdl_t* next = ga_ihdl_array[index].ahandle;
/* Loop over linked list and complete all remaining armci non-blocking calls */
while(next) {
ga_armcihdl_t* tmp = next->next;
/* Complete the call */
ARMCI_Wait(&next->handle);
/* reinitialize armci_hlt_t data structure */
next->next = NULL;
next->previous = NULL;
next->active = 0;
ARMCI_INIT_HANDLE(&next->handle);
next = tmp;
}
ga_ihdl_array[index].ahandle = NULL;
ga_ihdl_array[index].count = 0;
ga_ihdl_array[index].active = 0;
}
return(retval);
} | movl (%rdi), %edx
movzbl %dl, %ecx
movl %edx, %r8d
shrl $0x8, %r8d
leaq (%rcx,%rcx,2), %rax
leaq 0x44ce7(%rip), %rsi # 0xdea70
cmpl 0xc(%rsi,%rax,8), %r8d
jne 0x99df8
pushq %r15
pushq %r14
pushq %rbx
leaq (%rsi,%rax,8), %r14
cmpl $0x0, 0x10(%r14)
jne 0x99db8
leaq 0x42c01(%rip), %rax # 0xdc9a8
movq (%rax), %rsi
leaq 0x21432(%rip), %rdi # 0xbb1e3
xorl %eax, %eax
callq 0x3050
movq (%r14), %rbx
testq %rbx, %rbx
je 0x99de2
movq 0x8(%rbx), %r15
movq %rbx, %rdi
callq 0x59064
movl $0x0, 0x1c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %r15, %rbx
testq %r15, %r15
jne 0x99dc0
movq $0x0, (%r14)
xorl %eax, %eax
movl %eax, 0x8(%r14)
movl %eax, 0x10(%r14)
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
| /GlobalArrays[P]ga/global/src/nbutil.c |
ga_init_nbhandle | void ga_init_nbhandle(Integer *nbhandle)
{
int i, top, idx, iloc;
gai_nbhdl_t *inbhandle = (gai_nbhdl_t *)nbhandle;
lastGAhandle++;
lastGAhandle = lastGAhandle%nb_max_outstanding;
top = lastGAhandle+nb_max_outstanding;
/* default index if no handles are available */
idx = lastGAhandle;
for (i=lastGAhandle; i<top; i++) {
iloc = i%nb_max_outstanding;
if (ga_ihdl_array[iloc].ahandle == NULL) {
idx = iloc;
break;
}
}
/* If no free handle is found, clear the oldest handle */
if (ga_ihdl_array[idx].ahandle != NULL) {
Integer itmp;
/* find value of itmp corresponding to oldest handle */
gai_nbhdl_t *oldhdl = (gai_nbhdl_t*)&itmp;
oldhdl->ihdl_index = idx;
oldhdl->ga_nbtag = ga_ihdl_array[idx].ga_nbtag;
nga_wait_internal(&itmp);
}
inbhandle->ihdl_index = idx;
inbhandle->ga_nbtag = get_next_tag();
ga_ihdl_array[idx].ahandle = NULL;
ga_ihdl_array[idx].count = 0;
ga_ihdl_array[idx].active = 1;
ga_ihdl_array[idx].ga_nbtag = inbhandle->ga_nbtag;
/* reset lastGAhandle to idx */
lastGAhandle = idx;
return;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x3e2d9(%rip), %eax # 0xd8190
incl %eax
movl 0x3e2c9(%rip), %esi # 0xd8188
cltd
idivl %esi
movl %edx, %ebp
movl %edx, 0x3e2c6(%rip) # 0xd8190
testl %esi, %esi
jle 0x99ef8
movl %ebp, %edi
addl %esi, %edi
leaq 0x44b97(%rip), %r8 # 0xdea70
movl %ebp, %ecx
movl %ecx, %eax
cltd
idivl %esi
movslq %edx, %rax
leaq (%rax,%rax,2), %rax
cmpq $0x0, (%r8,%rax,8)
je 0x99ef6
incl %ecx
cmpl %edi, %ecx
jl 0x99edb
jmp 0x99ef8
movl %edx, %ebp
movslq %ebp, %rax
leaq (%rax,%rax,2), %rax
leaq 0x44b6a(%rip), %rcx # 0xdea70
leaq (%rcx,%rax,8), %r14
cmpq $0x0, (%r14)
je 0x99f2b
movzbl %bpl, %eax
leaq 0x8(%rsp), %rdi
movb %al, (%rdi)
movl 0xc(%r14), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, (%rdi)
callq 0x99d72
movzbl %bpl, %eax
movb %al, (%rbx)
movl 0x3e24d(%rip), %ecx # 0xd8184
incl %ecx
movl %ecx, %edx
andl $0xffffff, %edx # imm = 0xFFFFFF
movl %edx, 0x3e23d(%rip) # 0xd8184
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, (%rbx)
movq $0x0, (%r14)
movl $0x0, 0x8(%r14)
movl $0x1, 0x10(%r14)
movl %edx, 0xc(%r14)
movl %ebp, 0x3e221(%rip) # 0xd8190
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /GlobalArrays[P]ga/global/src/nbutil.c |
f2c_push_get_ | FATR f2c_push_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_push_get_(datatype, nelem, name, namesize, memhandle, index)
Integer *datatype;
Integer *nelem;
char *name;
int namesize; /* implicitly passed by FORTRAN */
Integer *memhandle;
MA_AccessIndex *index;
#endif /* F2C_HIDDEN_STRING_LENGTH_AFTER_ARGS */
{
Boolean value;
char buf[MA_NAMESIZE];
/* ensure that name is NUL-terminated */
ga_f2cstring(name, namesize, buf, (Integer)sizeof(buf));
value = MA_push_get(*datatype, *nelem, buf, memhandle, index);
/* FORTRAN array indexing is 1-based, so increment index */
(*index)++;
return value;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %rdx, %rdi
movl %r9d, %esi
movq %r13, %rdx
movl $0x20, %ecx
callq 0x57a28
movq (%r12), %rdi
movq (%r15), %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x56b40
incq (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /GlobalArrays[P]ga/ma/f2c.c |
ImGuiStorage::BuildSortByKey() | void ImGuiStorage::BuildSortByKey()
{
struct StaticFunc
{
static int IMGUI_CDECL PairCompareByID(const void* lhs, const void* rhs)
{
// We can't just do a subtraction because qsort uses signed integers and subtracting our ID doesn't play well with that.
if (((const ImGuiStoragePair*)lhs)->key > ((const ImGuiStoragePair*)rhs)->key) return +1;
if (((const ImGuiStoragePair*)lhs)->key < ((const ImGuiStoragePair*)rhs)->key) return -1;
return 0;
}
};
if (Data.Size > 1)
ImQsort(Data.Data, (size_t)Data.Size, sizeof(ImGuiStoragePair), StaticFunc::PairCompareByID);
} | movslq (%rdi), %rsi
cmpq $0x2, %rsi
jl 0x1c15f0
movq 0x8(%rdi), %rdi
leaq 0xc(%rip), %rcx # 0x1c15f2
movl $0x10, %edx
jmp 0x1a5d10
retq
nop
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGuiStorage::GetVoidPtrRef(unsigned int, void*) | void** ImGuiStorage::GetVoidPtrRef(ImGuiID key, void* default_val)
{
ImGuiStoragePair* it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
it = Data.insert(it, ImGuiStoragePair(key, default_val));
return &it->val_p;
} | subq $0x18, %rsp
movslq (%rdi), %r8
movq 0x8(%rdi), %rcx
testq %r8, %r8
je 0x1c184c
movq %rcx, %rax
movq %r8, %r10
movq %r8, %r9
shrq %r9
movq %r9, %r11
shlq $0x4, %r11
cmpl %esi, (%rax,%r11)
jae 0x1c1842
notq %r9
addq %r10, %r9
addq %r11, %rax
addq $0x10, %rax
movq %r9, %r10
testq %r9, %r9
jne 0x1c1825
jmp 0x1c1852
xorl %r8d, %r8d
movq %rcx, %rax
shlq $0x4, %r8
addq %r8, %rcx
cmpq %rcx, %rax
je 0x1c1862
cmpl %esi, (%rax)
je 0x1c1878
leaq 0x8(%rsp), %rcx
movl %esi, (%rcx)
movq %rdx, 0x8(%rcx)
movq %rax, %rsi
movq %rcx, %rdx
callq 0x1d817e
addq $0x8, %rax
addq $0x18, %rsp
retq
nop
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGuiStorage::SetFloat(unsigned int, float) | void ImGuiStorage::SetFloat(ImGuiID key, float val)
{
ImGuiStoragePair* it = LowerBound(Data, key);
if (it == Data.end() || it->key != key)
{
Data.insert(it, ImGuiStoragePair(key, val));
return;
}
it->val_f = val;
} | subq $0x18, %rsp
movslq (%rdi), %rdx
movq 0x8(%rdi), %rcx
testq %rdx, %rdx
je 0x1c193e
movq %rcx, %rax
movq %rdx, %r9
movq %rdx, %r8
shrq %r8
movq %r8, %r10
shlq $0x4, %r10
cmpl %esi, (%rax,%r10)
jae 0x1c1934
notq %r8
addq %r9, %r8
addq %r10, %rax
addq $0x10, %rax
movq %r8, %r9
testq %r8, %r8
jne 0x1c1917
jmp 0x1c1943
xorl %edx, %edx
movq %rcx, %rax
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x1c195a
cmpl %esi, (%rax)
jne 0x1c195a
movss %xmm0, 0x8(%rax)
jmp 0x1c196e
leaq 0x8(%rsp), %rdx
movl %esi, (%rdx)
movss %xmm0, 0x8(%rdx)
movq %rax, %rsi
callq 0x1d817e
addq $0x18, %rsp
retq
nop
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGuiTextFilter::PassFilter(char const*, char const*) const | bool ImGuiTextFilter::PassFilter(const char* text, const char* text_end) const
{
if (Filters.empty())
return true;
if (text == NULL)
text = "";
for (int i = 0; i != Filters.Size; i++)
{
const ImGuiTextRange& f = Filters[i];
if (f.empty())
continue;
if (f.b[0] == '-')
{
// Subtract
if (ImStristr(text, text_end, f.b + 1, f.e) != NULL)
return false;
}
else
{
// Grep
if (ImStristr(text, text_end, f.b, f.e) != NULL)
return true;
}
}
// Implicit * grep
if (CountGrep == 0)
return true;
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movl 0x100(%rdi), %r12d
testq %r12, %r12
je 0x1c1f81
testq %rsi, %rsi
leaq 0x3e6c34(%rip), %r15 # 0x5a8b41
cmovneq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq 0x108(%rdi), %r13
xorl %r14d, %r14d
testl %r12d, %r12d
movl $0x0, %ebx
cmovgl %r12d, %ebx
shlq $0x4, %rbx
shlq $0x4, %r12
cmpq %r14, %rbx
je 0x1c1f95
movq (%r13,%r14), %rdx
movq 0x8(%r13,%r14), %rcx
cmpq %rcx, %rdx
je 0x1c1f66
cmpb $0x2d, (%rdx)
setne %bpl
jne 0x1c1f54
incq %rdx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x1c0b68
testq %rax, %rax
jne 0x1c1f84
addq $0x10, %r14
cmpq %r14, %r12
jne 0x1c1f34
movq 0x10(%rsp), %rax
cmpl $0x0, 0x110(%rax)
sete %bpl
jmp 0x1c1f84
movb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x39c5a2(%rip), %rdi # 0x55e53e
leaq 0x39c5a4(%rip), %rsi # 0x55e547
leaq 0x39d560(%rip), %rcx # 0x55f50a
movl $0x4df, %edx # imm = 0x4DF
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::CalcListClipping(int, float, int*, int*) | void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (g.LogEnabled)
{
// If logging is active, do not perform any clipping
*out_items_display_start = 0;
*out_items_display_end = items_count;
return;
}
if (window->SkipItems)
{
*out_items_display_start = *out_items_display_end = 0;
return;
}
// We create the union of the ClipRect and the NavScoringRect which at worst should be 1 page away from ClipRect
ImRect unclipped_rect = window->ClipRect;
if (g.NavMoveRequest)
unclipped_rect.Add(g.NavScoringRectScreen);
const ImVec2 pos = window->DC.CursorPos;
int start = (int)((unclipped_rect.Min.y - pos.y) / items_height);
int end = (int)((unclipped_rect.Max.y - pos.y) / items_height);
// When performing a navigation request, ensure we have one item extra in the direction we are moving to
if (g.NavMoveRequest && g.NavMoveClipDir == ImGuiDir_Up)
start--;
if (g.NavMoveRequest && g.NavMoveClipDir == ImGuiDir_Down)
end++;
start = ImClamp(start, 0, items_count);
end = ImClamp(end + 1, start, items_count);
*out_items_display_start = start;
*out_items_display_end = end;
} | movq 0x5f2f54(%rip), %rax # 0x7b5230
cmpb $0x1, 0x2f18(%rax)
jne 0x1c22f0
movl $0x0, (%rsi)
jmp 0x1c23c6
movq 0x1a28(%rax), %r8
cmpb $0x1, 0x83(%r8)
jne 0x1c2308
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rsi)
retq
movss 0x244(%r8), %xmm3
movss 0x24c(%r8), %xmm4
movb 0x1c19(%rax), %cl
movaps %xmm4, %xmm1
unpcklps %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
cmpb $0x1, %cl
jne 0x1c2352
movss 0x1bbc(%rax), %xmm2
movss 0x1bc4(%rax), %xmm5
minss %xmm3, %xmm2
ucomiss %xmm4, %xmm5
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm2 # xmm2 = xmm2[2,0],xmm1[2,3]
jbe 0x1c234f
movss %xmm5, %xmm2 # xmm2 = xmm5[0],xmm2[1,2,3]
movaps %xmm2, %xmm1
movss 0xe4(%r8), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
subps %xmm2, %xmm1
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
divps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
testb %cl, %cl
je 0x1c2398
movd 0x1c2c(%rax), %xmm1
pshufd $0x50, %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1]
pcmpeqd 0x398f8a(%rip), %xmm1 # 0x55b310
pshufd $0x55, %xmm1, %xmm2 # xmm2 = xmm1[1,1,1,1]
psrld $0x1f, %xmm1
punpckldq %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
paddd %xmm1, %xmm0
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
movd %xmm1, %eax
cmpl %edi, %eax
movl %edi, %ecx
cmovll %eax, %ecx
xorl %r8d, %r8d
testl %eax, %eax
cmovnsl %ecx, %r8d
movd %xmm0, %eax
incl %eax
cmpl %edi, %eax
cmovll %eax, %edi
cmpl %r8d, %eax
cmovll %r8d, %edi
movl %r8d, (%rsi)
movl %edi, (%rdx)
retq
nop
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::FindRenderedTextEnd(char const*, char const*) | const char* ImGui::FindRenderedTextEnd(const char* text, const char* text_end)
{
const char* text_display_end = text;
if (!text_end)
text_end = (const char*)-1;
while (text_display_end < text_end && *text_display_end != '\0' && (text_display_end[0] != '#' || text_display_end[1] != '#'))
text_display_end++;
return text_display_end;
} | movq %rdi, %rax
xorl %ecx, %ecx
cmpq $0x1, %rsi
sbbq %rcx, %rcx
orq %rsi, %rcx
cmpq %rdi, %rcx
jbe 0x1c268d
movzbl (%rax), %edx
cmpl $0x23, %edx
je 0x1c267c
testl %edx, %edx
jne 0x1c2682
jmp 0x1c268d
cmpb $0x23, 0x1(%rax)
je 0x1c268d
incq %rax
cmpq %rcx, %rax
jne 0x1c266e
movq %rcx, %rax
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::LogRenderedText(ImVec2 const*, char const*, char const*) | void ImGui::LogRenderedText(const ImVec2* ref_pos, const char* text, const char* text_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (!text_end)
text_end = FindRenderedTextEnd(text, text_end);
const bool log_new_line = ref_pos && (ref_pos->y > g.LogLinePosY + 1);
if (ref_pos)
g.LogLinePosY = ref_pos->y;
if (log_new_line)
g.LogLineFirstItem = true;
const char* text_remaining = text;
if (g.LogDepthRef > window->DC.TreeDepth) // Re-adjust padding if we have popped out of our starting depth
g.LogDepthRef = window->DC.TreeDepth;
const int tree_depth = (window->DC.TreeDepth - g.LogDepthRef);
for (;;)
{
// Split the string. Each new line (after a '\n') is followed by spacing corresponding to the current depth of our log entry.
// We don't add a trailing \n to allow a subsequent item on the same line to be captured.
const char* line_start = text_remaining;
const char* line_end = ImStreolRange(line_start, text_end);
const bool is_first_line = (line_start == text);
const bool is_last_line = (line_end == text_end);
if (!is_last_line || (line_start != line_end))
{
const int char_count = (int)(line_end - line_start);
if (log_new_line || !is_first_line)
LogText(IM_NEWLINE "%*s%.*s", tree_depth * 4, "", char_count, line_start);
else if (g.LogLineFirstItem)
LogText("%*s%.*s", tree_depth * 4, "", char_count, line_start);
else
LogText(" %.*s", char_count, line_start);
g.LogLineFirstItem = false;
}
else if (log_new_line)
{
// An empty "" string at a different Y position should output a carriage return.
LogText(IM_NEWLINE);
break;
}
if (is_last_line)
break;
text_remaining = line_end + 1;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq 0x5f2a70(%rip), %r12 # 0x7b5230
testq %rdx, %rdx
jne 0x1c27f4
cmpq $-0x1, %rbx
je 0x1c27ed
movq %rbx, %r14
movzbl (%r14), %eax
cmpl $0x23, %eax
je 0x1c27dd
testl %eax, %eax
jne 0x1c27e4
jmp 0x1c27f4
cmpb $0x23, 0x1(%r14)
je 0x1c27f4
incq %r14
cmpq $-0x1, %r14
jne 0x1c27ce
movq $-0x1, %r14
movq 0x1a28(%r12), %rax
testq %rdi, %rdi
je 0x1c2838
movss 0x2f38(%r12), %xmm0
addss 0x398d9d(%rip), %xmm0 # 0x55b5b0
movss 0x4(%rdi), %xmm1
ucomiss %xmm0, %xmm1
movss %xmm1, 0x2f38(%r12)
jbe 0x1c2838
movb $0x1, 0x2f3c(%r12)
movb $0x1, %cl
movl %ecx, 0xc(%rsp)
jmp 0x1c2840
movl $0x0, 0xc(%rsp)
movl 0x2f40(%r12), %ecx
movl 0x118(%rax), %ebp
cmpl %ebp, %ecx
jle 0x1c285c
movl %ebp, 0x2f40(%r12)
movl %ebp, %ecx
subl %ecx, %ebp
shll $0x2, %ebp
movl 0xc(%rsp), %eax
movl %eax, %r15d
notb %r15b
movq %rbx, 0x10(%rsp)
movq %r14, %rdx
subq %rbx, %rdx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x1a5720
movq %rax, %r13
testq %rax, %rax
cmoveq %r14, %r13
movq %r13, %rax
xorq %r14, %rax
movq %rbx, %rcx
xorq %r13, %rcx
orq %rax, %rcx
jne 0x1c28a7
cmpb $0x0, 0xc(%rsp)
je 0x1c2905
jmp 0x1c2921
cmpq 0x10(%rsp), %rbx
sete %al
movl %r13d, %ecx
subl %ebx, %ecx
testb %al, %r15b
jne 0x1c28c2
leaq 0x39b19e(%rip), %rdi # 0x55da5e
jmp 0x1c28d4
cmpb $0x1, 0x2f3c(%r12)
jne 0x1c28e9
leaq 0x39b18b(%rip), %rdi # 0x55da5f
movl %ebp, %esi
leaq 0x3e6264(%rip), %rdx # 0x5a8b41
movq %rbx, %r8
xorl %eax, %eax
callq 0x1d581f
jmp 0x1c28fc
leaq 0x39b177(%rip), %rdi # 0x55da67
movl %ecx, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1d581f
movb $0x0, 0x2f3c(%r12)
leaq 0x1(%r13), %rbx
cmpq %r14, %r13
jne 0x1c2870
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3e7b1c(%rip), %rdi # 0x5aa444
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d581f
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::RenderTextClippedEx(ImDrawList*, ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*) | void ImGui::RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_display_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
// Perform CPU side clipping for single clipped element to avoid using scissor state
ImVec2 pos = pos_min;
const ImVec2 text_size = text_size_if_known ? *text_size_if_known : CalcTextSize(text, text_display_end, false, 0.0f);
const ImVec2* clip_min = clip_rect ? &clip_rect->Min : &pos_min;
const ImVec2* clip_max = clip_rect ? &clip_rect->Max : &pos_max;
bool need_clipping = (pos.x + text_size.x >= clip_max->x) || (pos.y + text_size.y >= clip_max->y);
if (clip_rect) // If we had no explicit clipping rectangle then pos==clip_min
need_clipping |= (pos.x < clip_min->x) || (pos.y < clip_min->y);
// Align whole block. We should defer that to the better rendering function when we'll have support for individual line alignment.
if (align.x > 0.0f) pos.x = ImMax(pos.x, pos.x + (pos_max.x - pos.x - text_size.x) * align.x);
if (align.y > 0.0f) pos.y = ImMax(pos.y, pos.y + (pos_max.y - pos.y - text_size.y) * align.y);
// Render
if (need_clipping)
{
ImVec4 fine_clip_rect(clip_min->x, clip_min->y, clip_max->x, clip_max->y);
draw_list->AddText(NULL, 0.0f, pos, GetColorU32(ImGuiCol_Text), text, text_display_end, 0.0f, &fine_clip_rect);
}
else
{
draw_list->AddText(NULL, 0.0f, pos, GetColorU32(ImGuiCol_Text), text, text_display_end, 0.0f, NULL);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq 0x98(%rsp), %rbp
movq (%rsi), %r15
movq %r15, 0x10(%rsp)
movd %r15d, %xmm7
shrq $0x20, %r15
testq %r9, %r9
je 0x1c2a62
movsd (%r9), %xmm0
jmp 0x1c2ac5
movq 0x5f27c7(%rip), %rax # 0x7b5230
movss 0x1920(%rax), %xmm0
cmpq %r14, %rbx
je 0x1c2aba
movq 0x1918(%rax), %rdi
movss 0x398b4f(%rip), %xmm1 # 0x55b5d4
xorps %xmm2, %xmm2
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
movdqa %xmm7, 0x20(%rsp)
callq 0x2042f4
movdqa 0x20(%rsp), %xmm7
movss 0x398b2f(%rip), %xmm1 # 0x55b5d8
addss %xmm0, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1,2,3]
jmp 0x1c2ac5
movq %xmm0, %xmm0 # xmm0 = xmm0[0],zero
xorps %xmm1, %xmm1
shufps $0xe2, %xmm1, %xmm0 # xmm0 = xmm0[2,0],xmm1[2,3]
movd %r15d, %xmm2
leaq 0x8(%rbp), %rax
testq %rbp, %rbp
cmovneq %rbp, %r12
cmoveq %r13, %rax
movaps %xmm0, %xmm3
addss %xmm7, %xmm3
movss (%rax), %xmm1
movb $0x1, %cl
ucomiss %xmm1, %xmm3
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3 # xmm3 = xmm3[1,1],xmm0[1,1]
jae 0x1c2b00
movaps %xmm3, %xmm4
addss %xmm2, %xmm4
ucomiss 0x4(%rax), %xmm4
setae %cl
movq 0x90(%rsp), %rdx
testq %rbp, %rbp
je 0x1c2b29
movss (%rbp), %xmm4
movb $0x1, %sil
ucomiss %xmm7, %xmm4
ja 0x1c2b26
movss 0x4(%rbp), %xmm4
ucomiss %xmm2, %xmm4
seta %sil
orb %sil, %cl
movss (%rdx), %xmm5
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm5
jbe 0x1c2b65
movss (%r13), %xmm6
subss %xmm7, %xmm6
subss %xmm0, %xmm6
mulss %xmm5, %xmm6
addss %xmm7, %xmm6
movaps %xmm6, %xmm0
cmpless %xmm7, %xmm0
movaps %xmm0, %xmm5
andnps %xmm6, %xmm5
andps %xmm7, %xmm0
orps %xmm5, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x4(%rdx), %xmm0
ucomiss %xmm4, %xmm0
jbe 0x1c2b9f
movss 0x4(%r13), %xmm4
subss %xmm2, %xmm4
subss %xmm3, %xmm4
mulss %xmm0, %xmm4
addss %xmm2, %xmm4
movaps %xmm4, %xmm0
cmpless %xmm2, %xmm0
movaps %xmm0, %xmm3
andnps %xmm4, %xmm3
andps %xmm2, %xmm0
orps %xmm3, %xmm0
movss %xmm0, 0x14(%rsp)
testb %cl, %cl
je 0x1c2bf7
movss 0x4(%rax), %xmm0
movsd (%r12), %xmm2
leaq 0x48(%rsp), %r15
movsd %xmm2, (%r15)
movss %xmm1, 0x8(%r15)
movss %xmm0, 0xc(%r15)
movq 0x5f2665(%rip), %rax # 0x7b5230
movups 0x1618(%rax), %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movss 0x1568(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x1c12b7
movq %r15, (%rsp)
jmp 0x1c2c2c
movq 0x5f2632(%rip), %rax # 0x7b5230
movups 0x1618(%rax), %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movss 0x1568(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x1c12b7
movq $0x0, (%rsp)
leaq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl %eax, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x1fba58
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::RenderTextClipped(ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*) | void ImGui::RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
// Hide anything after a '##' string
const char* text_display_end = FindRenderedTextEnd(text, text_end);
const int text_len = (int)(text_display_end - text);
if (text_len == 0)
return;
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
RenderTextClippedEx(window->DrawList, pos_min, pos_max, text, text_display_end, text_size_if_known, align, clip_rect);
if (g.LogEnabled)
LogRenderedText(&pos_min, text, text_display_end);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %r9
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
xorl %esi, %esi
cmpq $0x1, %rcx
sbbq %rsi, %rsi
orq %rcx, %rsi
movq %rbx, %r15
cmpq %rbx, %rsi
jbe 0x1c2d42
movzbl (%r15), %ecx
cmpl $0x23, %ecx
je 0x1c2d30
testl %ecx, %ecx
jne 0x1c2d37
jmp 0x1c2d42
cmpb $0x23, 0x1(%r15)
je 0x1c2d42
incq %r15
cmpq %rsi, %r15
jne 0x1c2d21
movq %rsi, %r15
cmpl %ebx, %r15d
je 0x1c2d98
movq 0x5f24e2(%rip), %r12 # 0x7b5230
movq 0x1a28(%r12), %rcx
movq 0x2b8(%rcx), %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %r15, %r8
pushq 0x30(%rsp)
pushq %rax
callq 0x1c2a1e
addq $0x10, %rsp
cmpb $0x1, 0x2f18(%r12)
jne 0x1c2d98
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1c27a5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::RenderFrameBorder(ImVec2, ImVec2, float) | void ImGui::RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
const float border_size = g.Style.FrameBorderSize;
if (border_size > 0.0f)
{
window->DrawList->AddRect(p_min+ImVec2(1,1), p_max+ImVec2(1,1), GetColorU32(ImGuiCol_BorderShadow), rounding, ImDrawCornerFlags_All, border_size);
window->DrawList->AddRect(p_min, p_max, GetColorU32(ImGuiCol_Border), rounding, ImDrawCornerFlags_All, border_size);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movlps %xmm0, 0x18(%rsp)
movlps %xmm1, 0x10(%rsp)
movq 0x5f1fe1(%rip), %rax # 0x7b5230
movss 0x15ac(%rax), %xmm4
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm4
jbe 0x1c334d
movq 0x1a28(%rax), %r13
movq 0x2b8(%r13), %rbx
movaps 0x398058(%rip), %xmm3 # 0x55b2d0
addps %xmm3, %xmm0
leaq 0x38(%rsp), %r14
movlps %xmm0, (%r14)
addps %xmm3, %xmm1
leaq 0x30(%rsp), %r15
movlps %xmm1, (%r15)
movups 0x1678(%rax), %xmm0
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
movss 0x1568(%rax), %xmm0
mulss 0xc(%r12), %xmm0
movss %xmm0, 0xc(%r12)
movq %r12, %rdi
movss %xmm2, 0x8(%rsp)
movss %xmm4, 0xc(%rsp)
callq 0x1c12b7
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %eax, %ecx
movss 0x8(%rsp), %xmm0
movl $0xf, %r8d
movss 0xc(%rsp), %xmm1
callq 0x1faba0
movq 0x2b8(%r13), %rbx
movq 0x5f1f35(%rip), %rax # 0x7b5230
movups 0x1668(%rax), %xmm0
movaps %xmm0, (%r12)
movss 0x1568(%rax), %xmm0
mulss 0xc(%r12), %xmm0
movss %xmm0, 0xc(%r12)
leaq 0x20(%rsp), %rdi
callq 0x1c12b7
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl %eax, %ecx
movss 0x8(%rsp), %xmm0
movl $0xf, %r8d
movss 0xc(%rsp), %xmm1
callq 0x1faba0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::RenderNavHighlight(ImRect const&, unsigned int, int) | void ImGui::RenderNavHighlight(const ImRect& bb, ImGuiID id, ImGuiNavHighlightFlags flags)
{
ImGuiContext& g = *GImGui;
if (id != g.NavId)
return;
if (g.NavDisableHighlight && !(flags & ImGuiNavHighlightFlags_AlwaysDraw))
return;
ImGuiWindow* window = g.CurrentWindow;
if (window->DC.NavHideHighlightOneFrame)
return;
float rounding = (flags & ImGuiNavHighlightFlags_NoRounding) ? 0.0f : g.Style.FrameRounding;
ImRect display_rect = bb;
display_rect.ClipWith(window->ClipRect);
if (flags & ImGuiNavHighlightFlags_TypeDefault)
{
const float THICKNESS = 2.0f;
const float DISTANCE = 3.0f + THICKNESS * 0.5f;
display_rect.Expand(ImVec2(DISTANCE,DISTANCE));
bool fully_visible = window->ClipRect.Contains(display_rect);
if (!fully_visible)
window->DrawList->PushClipRect(display_rect.Min, display_rect.Max);
window->DrawList->AddRect(display_rect.Min + ImVec2(THICKNESS*0.5f,THICKNESS*0.5f), display_rect.Max - ImVec2(THICKNESS*0.5f,THICKNESS*0.5f), GetColorU32(ImGuiCol_NavHighlight), rounding, ImDrawCornerFlags_All, THICKNESS);
if (!fully_visible)
window->DrawList->PopClipRect();
}
if (flags & ImGuiNavHighlightFlags_TypeThin)
{
window->DrawList->AddRect(display_rect.Min, display_rect.Max, GetColorU32(ImGuiCol_NavHighlight), rounding, ~0, 1.0f);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x5f19c9(%rip), %rax # 0x7b5230
cmpl %esi, 0x1b90(%rax)
jne 0x1c3a50
movl %edx, %ebx
testb $0x4, %bl
jne 0x1c3887
cmpb $0x0, 0x1bfe(%rax)
jne 0x1c3a50
movq 0x1a28(%rax), %r13
cmpb $0x0, 0x158(%r13)
jne 0x1c3a50
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
testb $0x8, %bl
jne 0x1c38b8
movss 0x15a8(%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movups (%rdi), %xmm0
movaps %xmm0, 0x10(%rsp)
movaps 0x10(%rsp), %xmm1
movups 0x240(%r13), %xmm0
movaps %xmm0, %xmm2
cmpleps %xmm1, %xmm2
movaps %xmm1, %xmm3
cmpltps %xmm0, %xmm3
movsd %xmm2, %xmm3 # xmm3 = xmm2[0],xmm3[1]
andps %xmm3, %xmm1
andnps %xmm0, %xmm3
orps %xmm1, %xmm3
movaps %xmm3, 0x10(%rsp)
testb $0x1, %bl
je 0x1c39ec
addps 0x397a43(%rip), %xmm3 # 0x55b340
movaps %xmm3, 0x10(%rsp)
movaps %xmm3, %xmm1
shufps $0x4e, %xmm0, %xmm1 # xmm1 = xmm1[2,3],xmm0[0,1]
shufps $0x4e, %xmm3, %xmm0 # xmm0 = xmm0[2,3],xmm3[0,1]
cmpleps %xmm0, %xmm1
movmskps %xmm1, %ebp
cmpl $0xf, %ebp
je 0x1c3950
movq 0x2b8(%r13), %rdi
movsd 0x10(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x18(%rsp), %xmm1
movaps %xmm1, 0x20(%rsp)
xorl %esi, %esi
callq 0x1f8b08
movaps 0x30(%rsp), %xmm1
movaps 0x20(%rsp), %xmm3
movq 0x5f18e2(%rip), %rax # 0x7b5230
jmp 0x1c3968
movaps 0x10(%rsp), %xmm0
movaps %xmm3, %xmm1
shufps $0x1, %xmm0, %xmm1 # xmm1 = xmm1[1,0],xmm0[0,0]
shufps $0xe2, %xmm0, %xmm1 # xmm1 = xmm1[2,0],xmm0[2,3]
shufps $0xe7, %xmm0, %xmm3 # xmm3 = xmm3[3,1],xmm0[2,3]
shufps $0xe2, %xmm0, %xmm3 # xmm3 = xmm3[2,0],xmm0[2,3]
movq 0x2b8(%r13), %r14
addps 0x39795a(%rip), %xmm1 # 0x55b2d0
leaq 0x60(%rsp), %r15
movlps %xmm1, (%r15)
addps 0x3979ca(%rip), %xmm3 # 0x55b350
leaq 0x58(%rsp), %r12
movlps %xmm3, (%r12)
movups 0x18d8(%rax), %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
movss 0x1568(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x1c12b7
movss 0x397c46(%rip), %xmm1 # 0x55b604
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %eax, %ecx
movss 0xc(%rsp), %xmm0
movl $0xf, %r8d
callq 0x1faba0
cmpb $0xf, %bpl
je 0x1c39ec
movq 0x2b8(%r13), %rdi
callq 0x1f8c84
testb $0x2, %bl
je 0x1c3a50
leaq 0x18(%rsp), %rbx
movq 0x2b8(%r13), %r14
movq 0x5f182c(%rip), %rax # 0x7b5230
movups 0x18d8(%rax), %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
movss 0x1568(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x1c12b7
leaq 0x10(%rsp), %rsi
movss 0x397b79(%rip), %xmm1 # 0x55b5b0
movq %r14, %rdi
movq %rbx, %rdx
movl %eax, %ecx
movss 0xc(%rsp), %xmm0
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
callq 0x1faba0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::IsItemHovered(int) | bool ImGui::IsItemHovered(ImGuiHoveredFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (g.NavDisableMouseHover && !g.NavDisableHighlight)
return IsItemFocused();
// Test for bounding box overlap, as updated as ItemAdd()
if (!(window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HoveredRect))
return false;
IM_ASSERT((flags & (ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows)) == 0); // Flags not supported by this function
// Test if we are hovering the right window (our window could be behind another window)
// [2017/10/16] Reverted commit 344d48be3 and testing RootWindow instead. I believe it is correct to NOT test for RootWindow but this leaves us unable to use IsItemHovered() after EndChild() itself.
// Until a solution is found I believe reverting to the test from 2017/09/27 is safe since this was the test that has been running for a long while.
//if (g.HoveredWindow != window)
// return false;
if (g.HoveredRootWindow != window->RootWindow && !(flags & ImGuiHoveredFlags_AllowWhenOverlapped))
return false;
// Test if another item is active (e.g. being dragged)
if (!(flags & ImGuiHoveredFlags_AllowWhenBlockedByActiveItem))
if (g.ActiveId != 0 && g.ActiveId != window->DC.LastItemId && !g.ActiveIdAllowOverlap && g.ActiveId != window->MoveId)
return false;
// Test if interactions on this window are blocked by an active popup or modal.
// The ImGuiHoveredFlags_AllowWhenBlockedByPopup flag will be tested here.
if (!IsWindowContentHoverable(window, flags))
return false;
// Test if the item is disabled
if ((window->DC.ItemFlags & ImGuiItemFlags_Disabled) && !(flags & ImGuiHoveredFlags_AllowWhenDisabled))
return false;
// Special handling for the dummy item after Begin() which represent the title bar or tab.
// When the window is collapsed (SkipItems==true) that last item will never be overwritten so we need to detect the case.
if (window->DC.LastItemId == window->MoveId && window->WriteAccessed)
return false;
return true;
} | movq 0x5f033c(%rip), %rcx # 0x7b5230
movq 0x1a28(%rcx), %rax
cmpb $0x1, 0x1bff(%rcx)
jne 0x1c4f11
cmpb $0x0, 0x1bfe(%rcx)
je 0x1c4fc9
testb $0x1, 0x124(%rax)
je 0x1c4fdd
testb $0x3, %dil
jne 0x1c4fe0
movq 0x370(%rax), %rdx
testb $0x40, %dil
jne 0x1c4f42
cmpq %rdx, 0x1a38(%rcx)
jne 0x1c4fdd
testb $0x20, %dil
jne 0x1c4f68
movl 0x1a70(%rcx), %esi
testl %esi, %esi
je 0x1c4f68
cmpl 0x120(%rax), %esi
je 0x1c4f68
cmpb $0x0, 0x1a7d(%rcx)
jne 0x1c4f68
cmpl 0x4c(%rax), %esi
jne 0x1c4fdd
movq 0x1b88(%rcx), %rcx
testq %rcx, %rcx
je 0x1c4fa2
movq 0x370(%rcx), %rcx
testq %rcx, %rcx
je 0x1c4fa2
cmpq %rdx, %rcx
je 0x1c4fa2
cmpb $0x0, 0x7f(%rcx)
je 0x1c4fa2
movl 0xc(%rcx), %ecx
btl $0x1b, %ecx
jb 0x1c4fdd
testb $0x8, %dil
jne 0x1c4fa2
andl $0x4000000, %ecx # imm = 0x4000000
jne 0x1c4fdd
testb %dil, %dil
js 0x1c4fb2
movl 0x190(%rax), %ecx
andl $0x4, %ecx
jne 0x1c4fdd
movl 0x120(%rax), %ecx
cmpl 0x4c(%rax), %ecx
jne 0x1c4fc6
cmpb $0x0, 0x80(%rax)
jne 0x1c4fdd
movb $0x1, %al
retq
movl 0x1b90(%rcx), %ecx
testl %ecx, %ecx
je 0x1c4fdd
cmpl 0x120(%rax), %ecx
sete %al
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x39704b(%rip), %rdi # 0x55c033
leaq 0x396df4(%rip), %rsi # 0x55bde3
leaq 0x39708c(%rip), %rcx # 0x55c082
movl $0xbf1, %edx # imm = 0xBF1
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImDrawDataBuilder::FlattenIntoSingleLayer() | void ImDrawDataBuilder::FlattenIntoSingleLayer()
{
int n = Layers[0].Size;
int size = n;
for (int i = 1; i < IM_ARRAYSIZE(Layers); i++)
size += Layers[i].Size;
Layers[0].resize(size);
for (int layer_n = 1; layer_n < IM_ARRAYSIZE(Layers); layer_n++)
{
ImVector<ImDrawList*>& layer = Layers[layer_n];
if (layer.empty())
continue;
memcpy(&Layers[0][n], &layer[0], layer.Size * sizeof(ImDrawList*));
n += layer.Size;
layer.resize(0);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdi), %r14
movl 0x4(%rdi), %ecx
movl 0x10(%rdi), %r12d
leal (%r12,%r14), %ebp
movl %r12d, %eax
cmpl %ebp, %ecx
jge 0x1cdb48
testl %ecx, %ecx
je 0x1cdac7
movl %ecx, %r13d
shrl $0x1f, %r13d
addl %ecx, %r13d
sarl %r13d
addl %ecx, %r13d
jmp 0x1cdacd
movl $0x8, %r13d
cmpl %ebp, %r13d
cmovlel %ebp, %r13d
movslq %r13d, %rdi
shlq $0x3, %rdi
movq 0x5e774e(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1cdaed
incl 0x3c0(%rax)
movq 0x5e774c(%rip), %rsi # 0x7b5240
callq *0x5df016(%rip) # 0x7acb10
movq %rax, %r15
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1cdb3d
movslq (%rbx), %rdx
shlq $0x3, %rdx
movq %r15, %rdi
callq 0x1a5110
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1cdb30
movq 0x5e770b(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1cdb30
decl 0x3c0(%rax)
movq 0x5e7709(%rip), %rsi # 0x7b5240
callq *0x5defdb(%rip) # 0x7acb18
movq %r15, 0x8(%rbx)
movl %r13d, 0x4(%rbx)
movl 0x10(%rbx), %eax
movl %ebp, (%rbx)
testl %eax, %eax
je 0x1cdbfa
testl %r12d, %r12d
jle 0x1cdc09
testl %eax, %eax
jle 0x1cdc09
shlq $0x3, %r14
addq 0x8(%rbx), %r14
movq 0x18(%rbx), %rsi
movl %eax, %edx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0x1a5110
cmpl $0x0, 0x14(%rbx)
jns 0x1cdbf3
movq 0x5e76a6(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1cdb95
incl 0x3c0(%rax)
movq 0x5e76a4(%rip), %rsi # 0x7b5240
xorl %edi, %edi
callq *0x5def6c(%rip) # 0x7acb10
movq %rax, %r14
movq 0x18(%rbx), %rsi
testq %rsi, %rsi
je 0x1cdbe8
movslq 0x10(%rbx), %rdx
shlq $0x3, %rdx
movq %r14, %rdi
callq 0x1a5110
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1cdbdb
movq 0x5e7660(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1cdbdb
decl 0x3c0(%rax)
movq 0x5e765e(%rip), %rsi # 0x7b5240
callq *0x5def30(%rip) # 0x7acb18
movq %r14, 0x18(%rbx)
movl $0x0, 0x14(%rbx)
movl $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x39092e(%rip), %rdi # 0x55e53e
leaq 0x390930(%rip), %rsi # 0x55e547
leaq 0x391ac6(%rip), %rcx # 0x55f6e4
movl $0x4de, %edx # imm = 0x4DE
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::End() | void ImGui::End()
{
ImGuiContext& g = *GImGui;
if (g.CurrentWindowStack.Size <= 1 && g.FrameScopePushedImplicitWindow)
{
IM_ASSERT(g.CurrentWindowStack.Size > 1 && "Calling End() too many times!");
return; // FIXME-ERRORHANDLING
}
IM_ASSERT(g.CurrentWindowStack.Size > 0);
ImGuiWindow* window = g.CurrentWindow;
if (window->DC.CurrentColumns)
EndColumns();
PopClipRect(); // Inner window clip rectangle
// Stop logging
if (!(window->Flags & ImGuiWindowFlags_ChildWindow)) // FIXME: add more options for scope of logging
LogFinish();
// Pop from window stack
g.CurrentWindowStack.pop_back();
if (window->Flags & ImGuiWindowFlags_Popup)
g.BeginPopupStack.pop_back();
CheckStacksSize(window, false);
SetCurrentWindow(g.CurrentWindowStack.empty() ? NULL : g.CurrentWindowStack.back());
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x5e6da0(%rip), %rbx # 0x7b5230
movl 0x1a00(%rbx), %eax
cmpl $0x1, %eax
jg 0x1ce4ae
cmpb $0x1, 0x2(%rbx)
je 0x1ce6c4
cmpl $0x1, %eax
jne 0x1ce6e3
movq 0x1a28(%rbx), %r14
cmpq $0x0, 0x1f8(%r14)
je 0x1ce4c4
callq 0x1f109c
callq 0x1cdc9c
testb $0x1, 0xf(%r14)
jne 0x1ce4d5
callq 0x1d0d62
movl 0x1a00(%rbx), %eax
testl %eax, %eax
jle 0x1ce5f0
decl %eax
movl %eax, 0x1a00(%rbx)
testb $0x4, 0xf(%r14)
je 0x1ce508
movl 0x1b78(%rbx), %ecx
testl %ecx, %ecx
jle 0x1ce702
decl %ecx
movl %ecx, 0x1b78(%rbx)
movswl 0x1e0(%r14), %ecx
cmpl %ecx, 0xd0(%r14)
jne 0x1ce60a
movswl 0x1e2(%r14), %ecx
cmpl %ecx, 0x1d0(%r14)
jne 0x1ce629
movq 0x5e6cf7(%rip), %rcx # 0x7b5230
movswl 0x1e4(%r14), %edx
cmpl %edx, 0x1b78(%rcx)
jne 0x1ce648
movswl 0x1e6(%r14), %edx
cmpl %edx, 0x1b38(%rcx)
jg 0x1ce667
movswl 0x1e8(%r14), %edx
cmpl %edx, 0x1b48(%rcx)
jg 0x1ce686
movswl 0x1ea(%r14), %edx
cmpl %edx, 0x1b58(%rcx)
jg 0x1ce6a5
testl %eax, %eax
je 0x1ce5dd
movq 0x1a08(%rbx), %rdx
movl %eax, %eax
movq -0x8(%rdx,%rax,8), %rax
movq %rax, 0x1a28(%rcx)
testq %rax, %rax
je 0x1ce5e8
movss 0x1924(%rcx), %xmm0
mulss 0x2b0(%rax), %xmm0
movq 0x368(%rax), %rax
testq %rax, %rax
je 0x1ce5cb
mulss 0x2b0(%rax), %xmm0
movss %xmm0, 0x1938(%rcx)
movss %xmm0, 0x1920(%rcx)
jmp 0x1ce5e8
movq $0x0, 0x1a28(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x39a6da(%rip), %rdi # 0x568cd1
leaq 0x38ff49(%rip), %rsi # 0x55e547
leaq 0x3911f8(%rip), %rcx # 0x55f7fd
jmp 0x1ce717
leaq 0x3902cc(%rip), %rdi # 0x55e8dd
leaq 0x38d7cb(%rip), %rsi # 0x55bde3
leaq 0x390303(%rip), %rcx # 0x55e922
movl $0x12d5, %edx # imm = 0x12D5
callq 0x1a5270
leaq 0x39031c(%rip), %rdi # 0x55e94c
leaq 0x38d7ac(%rip), %rsi # 0x55bde3
leaq 0x3902e4(%rip), %rcx # 0x55e922
movl $0x12d6, %edx # imm = 0x12D6
callq 0x1a5270
leaq 0x390335(%rip), %rdi # 0x55e984
leaq 0x38d78d(%rip), %rsi # 0x55bde3
leaq 0x3902c5(%rip), %rcx # 0x55e922
movl $0x12d7, %edx # imm = 0x12D7
callq 0x1a5270
leaq 0x390362(%rip), %rdi # 0x55e9d0
leaq 0x38d76e(%rip), %rsi # 0x55bde3
leaq 0x3902a6(%rip), %rcx # 0x55e922
movl $0x12d9, %edx # imm = 0x12D9
callq 0x1a5270
leaq 0x390384(%rip), %rdi # 0x55ea11
leaq 0x38d74f(%rip), %rsi # 0x55bde3
leaq 0x390287(%rip), %rcx # 0x55e922
movl $0x12da, %edx # imm = 0x12DA
callq 0x1a5270
leaq 0x3903a2(%rip), %rdi # 0x55ea4e
leaq 0x38d730(%rip), %rsi # 0x55bde3
leaq 0x390268(%rip), %rcx # 0x55e922
movl $0x12db, %edx # imm = 0x12DB
callq 0x1a5270
leaq 0x38e507(%rip), %rdi # 0x55cbd2
leaq 0x38d711(%rip), %rsi # 0x55bde3
leaq 0x38e53a(%rip), %rcx # 0x55cc13
movl $0x177e, %edx # imm = 0x177E
callq 0x1a5270
leaq 0x38e53b(%rip), %rdi # 0x55cc25
leaq 0x38d6f2(%rip), %rsi # 0x55bde3
leaq 0x38e51b(%rip), %rcx # 0x55cc13
movl $0x1781, %edx # imm = 0x1781
callq 0x1a5270
leaq 0x39a5c8(%rip), %rdi # 0x568cd1
leaq 0x38fe37(%rip), %rsi # 0x55e547
leaq 0x391123(%rip), %rcx # 0x55f83a
movl $0x4f3, %edx # imm = 0x4F3
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::ClearDragDrop() | void ImGui::ClearDragDrop()
{
ImGuiContext& g = *GImGui;
g.DragDropActive = false;
g.DragDropPayload.Clear();
g.DragDropAcceptFlags = ImGuiDragDropFlags_None;
g.DragDropAcceptIdCurr = g.DragDropAcceptIdPrev = 0;
g.DragDropAcceptIdCurrRectSurface = FLT_MAX;
g.DragDropAcceptFrameCount = -1;
g.DragDropPayloadBufHeap.clear();
memset(&g.DragDropPayloadBufLocal, 0, sizeof(g.DragDropPayloadBufLocal));
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x5e6ace(%rip), %rbx # 0x7b5230
xorl %eax, %eax
movb %al, 0x1e9c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1ec8(%rbx)
movups %xmm0, 0x1ed8(%rbx)
movb %al, 0x1ee8(%rbx)
movups %xmm0, 0x1eb0(%rbx)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rax, 0x1ec0(%rbx)
movw $0x0, 0x1ee9(%rbx)
movl $0x0, 0x1f04(%rbx)
movq %rax, 0x1f10(%rbx)
movq $0x7f7fffff, 0x1f08(%rbx) # imm = 0x7F7FFFFF
movq 0x1f20(%rbx), %rdi
testq %rdi, %rdi
je 0x1ce7ee
xorl %r14d, %r14d
movq %r14, 0x1f18(%rbx)
decl 0x3c0(%rbx)
movq 0x5e6a5f(%rip), %rsi # 0x7b5240
callq *0x5de331(%rip) # 0x7acb18
movq %r14, 0x1f20(%rbx)
movq $0x0, 0x1f28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::IsKeyPressed(int, bool) | bool ImGui::IsKeyPressed(int user_key_index, bool repeat)
{
ImGuiContext& g = *GImGui;
if (user_key_index < 0)
return false;
IM_ASSERT(user_key_index >= 0 && user_key_index < IM_ARRAYSIZE(g.IO.KeysDown));
const float t = g.IO.KeysDownDuration[user_key_index];
if (t == 0.0f)
return true;
if (repeat && t > g.IO.KeyRepeatDelay)
return GetKeyPressedAmount(user_key_index, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate) > 0;
return false;
} | pushq %rax
testl %edi, %edi
js 0x1cf056
cmpl $0x200, %edi # imm = 0x200
jae 0x1cf05a
movq 0x5e621d(%rip), %rcx # 0x7b5230
movl %edi, %eax
movss 0x4a8(%rcx,%rax,4), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
setnp %dl
sete %al
andb %dl, %al
xorb $0x1, %sil
orb %al, %sil
jne 0x1cf058
movss 0x94(%rcx), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x1cf056
movss 0x98(%rcx), %xmm1
callq 0x1cef6d
testl %eax, %eax
setg %al
jmp 0x1cf058
xorl %eax, %eax
popq %rcx
retq
leaq 0x38d60b(%rip), %rdi # 0x55c66c
leaq 0x38cd7b(%rip), %rsi # 0x55bde3
leaq 0x38d6fc(%rip), %rcx # 0x55c76b
movl $0x1140, %edx # imm = 0x1140
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::IsMouseClicked(int, bool) | bool ImGui::IsMouseClicked(int button, bool repeat)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
const float t = g.IO.MouseDownDuration[button];
if (t == 0.0f)
return true;
if (repeat && t > g.IO.KeyRepeatDelay)
{
// FIXME: 2019/05/03: Our old repeat code was wrong here and led to doubling the repeat rate, which made it an ok rate for repeat on mouse hold.
int amount = CalcTypematicPressedRepeatAmount(t, t - g.IO.DeltaTime, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate * 0.5f);
if (amount > 0)
return true;
}
return false;
} | cmpl $0x5, %edi
jae 0x1cf188
movq 0x5e6121(%rip), %rcx # 0x7b5230
movl %edi, %eax
movss 0x444(%rcx,%rax,4), %xmm0
movb $0x1, %al
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1cf127
jp 0x1cf127
retq
testb %sil, %sil
je 0x1cf185
movss 0x94(%rcx), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x1cf185
ucomiss %xmm0, %xmm1
jae 0x1cf185
movss 0x98(%rcx), %xmm2
mulss 0x38c46e(%rip), %xmm2 # 0x55b5bc
xorps %xmm3, %xmm3
ucomiss %xmm2, %xmm3
jae 0x1cf185
movaps %xmm0, %xmm3
subss 0x18(%rcx), %xmm3
unpcklps %xmm3, %xmm0 # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
subps %xmm1, %xmm0
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
divps %xmm2, %xmm0
cvttps2dq %xmm0, %xmm0
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
pcmpgtd %xmm1, %xmm0
movd %xmm0, %ecx
testb $0x1, %cl
jne 0x1cf126
xorl %eax, %eax
retq
pushq %rax
leaq 0x38d61e(%rip), %rdi # 0x55c7ae
leaq 0x38cc4c(%rip), %rsi # 0x55bde3
leaq 0x38d67d(%rip), %rcx # 0x55c81b
movl $0x1164, %edx # imm = 0x1164
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::GetMouseDragDelta(int, float) | ImVec2 ImGui::GetMouseDragDelta(int button, float lock_threshold)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
if (lock_threshold < 0.0f)
lock_threshold = g.IO.MouseDragThreshold;
if (g.IO.MouseDown[button] || g.IO.MouseReleased[button])
if (g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold)
if (IsMousePosValid(&g.IO.MousePos) && IsMousePosValid(&g.IO.MouseClickedPos[button]))
return g.IO.MousePos - g.IO.MouseClickedPos[button];
return ImVec2(0.0f, 0.0f);
} | pushq %r15
pushq %r14
pushq %rbx
cmpl $0x5, %edi
jae 0x1cf3ac
movq 0x5e5f0b(%rip), %r14 # 0x7b5230
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1cf333
movss 0x38(%r14), %xmm0
movl %edi, %r15d
cmpb $0x0, 0x138(%r14,%r15)
jne 0x1cf34f
xorps %xmm2, %xmm2
cmpb $0x1, 0x432(%r14,%r15)
jne 0x1cf3a3
movss 0x494(%r14,%r15,4), %xmm1
mulss %xmm0, %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm0, %xmm1
jb 0x1cf3a3
leaq 0x130(%r14), %rbx
movq %rbx, %rdi
callq 0x1c601c
testb %al, %al
je 0x1cf3a0
leaq (%r14,%r15,8), %r14
addq $0x3d4, %r14 # imm = 0x3D4
movq %r14, %rdi
callq 0x1c601c
testb %al, %al
xorps %xmm2, %xmm2
je 0x1cf3a3
movsd (%rbx), %xmm2
movsd (%r14), %xmm0
subps %xmm0, %xmm2
jmp 0x1cf3a3
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x38d3fb(%rip), %rdi # 0x55c7ae
leaq 0x38ca29(%rip), %rsi # 0x55bde3
leaq 0x38d55d(%rip), %rcx # 0x55c91e
movl $0x11b4, %edx # imm = 0x11B4
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::IsItemActivated() | bool ImGui::IsItemActivated()
{
ImGuiContext& g = *GImGui;
if (g.ActiveId)
{
ImGuiWindow* window = g.CurrentWindow;
if (g.ActiveId == window->DC.LastItemId && g.ActiveIdPreviousFrame != window->DC.LastItemId)
return true;
}
return false;
} | movq 0x5e5dc3(%rip), %rcx # 0x7b5230
movl 0x1a70(%rcx), %edx
testl %edx, %edx
je 0x1cf490
movq 0x1a28(%rcx), %rax
cmpl 0x120(%rax), %edx
jne 0x1cf490
movb $0x1, %al
cmpl %edx, 0x1aa4(%rcx)
jne 0x1cf492
xorl %eax, %eax
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::IsItemClicked(int) | bool ImGui::IsMouseClicked(int button, bool repeat)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
const float t = g.IO.MouseDownDuration[button];
if (t == 0.0f)
return true;
if (repeat && t > g.IO.KeyRepeatDelay)
{
// FIXME: 2019/05/03: Our old repeat code was wrong here and led to doubling the repeat rate, which made it an ok rate for repeat on mouse hold.
int amount = CalcTypematicPressedRepeatAmount(t, t - g.IO.DeltaTime, g.IO.KeyRepeatDelay, g.IO.KeyRepeatRate * 0.5f);
if (amount > 0)
return true;
}
return false;
} | cmpl $0x5, %edi
jae 0x1cf52c
movq 0x5e5d23(%rip), %rax # 0x7b5230
movl %edi, %ecx
movss 0x444(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1cf529
jp 0x1cf529
xorl %edi, %edi
jmp 0x1c4eed
xorl %eax, %eax
retq
pushq %rax
leaq 0x38d27a(%rip), %rdi # 0x55c7ae
leaq 0x38c8a8(%rip), %rsi # 0x55bde3
leaq 0x38d2d9(%rip), %rcx # 0x55c81b
movl $0x1164, %edx # imm = 0x1164
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::BeginChildEx(char const*, unsigned int, ImVec2 const&, bool, int) | static bool ImGui::BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, bool border, ImGuiWindowFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* parent_window = g.CurrentWindow;
flags |= ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_ChildWindow;
flags |= (parent_window->Flags & ImGuiWindowFlags_NoMove); // Inherit the NoMove flag
// Size
const ImVec2 content_avail = GetContentRegionAvail();
ImVec2 size = ImFloor(size_arg);
const int auto_fit_axises = ((size.x == 0.0f) ? (1 << ImGuiAxis_X) : 0x00) | ((size.y == 0.0f) ? (1 << ImGuiAxis_Y) : 0x00);
if (size.x <= 0.0f)
size.x = ImMax(content_avail.x + size.x, 4.0f); // Arbitrary minimum child size (0.0f causing too much issues)
if (size.y <= 0.0f)
size.y = ImMax(content_avail.y + size.y, 4.0f);
SetNextWindowSize(size);
// Build up name. If you need to append to a same child from multiple location in the ID stack, use BeginChild(ImGuiID id) with a stable value.
char title[256];
if (name)
ImFormatString(title, IM_ARRAYSIZE(title), "%s/%s_%08X", parent_window->Name, name, id);
else
ImFormatString(title, IM_ARRAYSIZE(title), "%s/%08X", parent_window->Name, id);
const float backup_border_size = g.Style.ChildBorderSize;
if (!border)
g.Style.ChildBorderSize = 0.0f;
bool ret = Begin(title, NULL, flags);
g.Style.ChildBorderSize = backup_border_size;
ImGuiWindow* child_window = g.CurrentWindow;
child_window->ChildId = id;
child_window->AutoFitChildAxises = auto_fit_axises;
// Set the cursor to handle case where the user called SetNextWindowPos()+BeginChild() manually.
// While this is not really documented/defined, it seems that the expected thing to do.
if (child_window->BeginCount == 1)
parent_window->DC.CursorPos = child_window->Pos;
// Process navigation-in immediately so NavInit can run on first frame
if (g.NavActivateId == id && !(flags & ImGuiWindowFlags_NavFlattened) && (child_window->DC.NavLayerActiveMask != 0 || child_window->DC.NavHasScroll))
{
FocusWindow(child_window);
NavInitWindow(child_window, false);
SetActiveID(id+1, child_window); // Steal ActiveId with a dummy id so that key-press won't activate child item
g.ActiveIdSource = ImGuiInputSource_Nav;
}
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movl %edx, %r14d
movl %esi, %ebx
movq %rdi, %r8
movq 0x5e5b1a(%rip), %r12 # 0x7b5230
movq 0x1a28(%r12), %r13
movsd 0x258(%r13), %xmm2
cmpq $0x0, 0x1f8(%r13)
je 0x1cf73e
movss 0x238(%r13), %xmm3
movss %xmm3, %xmm2 # xmm2 = xmm3[0],xmm2[1,2,3]
movl 0xc(%r13), %r15d
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
cvttps2dq %xmm0, %xmm1
cvtdq2ps %xmm1, %xmm0
movd %xmm1, %eax
testl %eax, %eax
jg 0x1cf774
movss 0xe0(%r13), %xmm3
movaps %xmm2, %xmm4
subss %xmm3, %xmm4
addss %xmm0, %xmm4
maxss 0x38bed4(%rip), %xmm4 # 0x55b644
movss %xmm4, %xmm0 # xmm0 = xmm4[0],xmm0[1,2,3]
andl $0x4, %r15d
pshufd $0x50, %xmm1, %xmm5 # xmm5 = xmm1[0,0,1,1]
pxor %xmm1, %xmm1
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3 # xmm3 = xmm3[1,1],xmm0[1,1]
xorps %xmm4, %xmm4
ucomiss %xmm3, %xmm4
jb 0x1cf7b3
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
subss 0xe4(%r13), %xmm2
addss %xmm2, %xmm3
maxss 0x38be9b(%rip), %xmm3 # 0x55b644
movlhps %xmm0, %xmm3 # xmm3 = xmm3[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm3 # xmm3 = xmm3[2,0],xmm0[2,3]
movaps %xmm3, %xmm0
movl %ecx, 0xc(%rsp)
orl %ecx, %r15d
pcmpeqd %xmm1, %xmm5
movdqa %xmm5, 0x10(%rsp)
orb $0x2, 0x1ac0(%r12)
movlps %xmm0, 0x1ae0(%r12)
movl $0x1, 0x1ac8(%r12)
movq (%r13), %rcx
testq %r8, %r8
je 0x1cf808
leaq 0x38f010(%rip), %rdx # 0x55e802
leaq 0x20(%rsp), %rdi
movl $0x100, %esi # imm = 0x100
movl %ebx, %r9d
xorl %eax, %eax
callq 0x1c0c8a
jmp 0x1cf823
leaq 0x38effe(%rip), %rdx # 0x55e80d
leaq 0x20(%rsp), %rdi
movl $0x100, %esi # imm = 0x100
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1c0c8a
orl $0x1000103, %r15d # imm = 0x1000103
movapd 0x10(%rsp), %xmm0
movmskpd %xmm0, %ebp
movss 0x1594(%r12), %xmm0
movss %xmm0, 0x10(%rsp)
testb %r14b, %r14b
jne 0x1cf855
movl $0x0, 0x1594(%r12)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0x1c986f
movl %eax, %r14d
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x1594(%r12)
movq 0x1a28(%r12), %r15
movl %ebx, 0x50(%r15)
movl %ebp, 0xa0(%r15)
cmpw $0x1, 0x88(%r15)
jne 0x1cf8a0
movq 0x10(%r15), %rax
movq %rax, 0xe0(%r13)
btl $0x17, 0xc(%rsp)
jb 0x1cf8f0
cmpl %ebx, 0x1b94(%r12)
jne 0x1cf8f0
cmpl $0x0, 0x150(%r15)
jne 0x1cf8c6
cmpb $0x1, 0x159(%r15)
jne 0x1cf8f0
movq %r15, %rdi
callq 0x1c5cfc
movq %r15, %rdi
xorl %esi, %esi
callq 0x1d0c00
incl %ebx
movl %ebx, %edi
movq %r15, %rsi
callq 0x1c4657
movl $0x2, 0x1aa0(%r12)
movl %r14d, %eax
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::EndChild() | void ImGui::EndChild()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
IM_ASSERT(window->Flags & ImGuiWindowFlags_ChildWindow); // Mismatched BeginChild()/EndChild() callss
if (window->BeginCount > 1)
{
End();
}
else
{
ImVec2 sz = window->Size;
if (window->AutoFitChildAxises & (1 << ImGuiAxis_X)) // Arbitrary minimum zero-ish child size of 4.0f causes less trouble than a 0.0f
sz.x = ImMax(4.0f, sz.x);
if (window->AutoFitChildAxises & (1 << ImGuiAxis_Y))
sz.y = ImMax(4.0f, sz.y);
End();
ImGuiWindow* parent_window = g.CurrentWindow;
ImRect bb(parent_window->DC.CursorPos, parent_window->DC.CursorPos + sz);
ItemSize(sz);
if ((window->DC.NavLayerActiveMask != 0 || window->DC.NavHasScroll) && !(window->Flags & ImGuiWindowFlags_NavFlattened))
{
ItemAdd(bb, window->ChildId);
RenderNavHighlight(bb, window->ChildId);
// When browsing a window that has no activable items (scroll only) we keep a highlight on the child
if (window->DC.NavLayerActiveMask == 0 && window == g.NavWindow)
RenderNavHighlight(ImRect(bb.Min - ImVec2(2,2), bb.Max + ImVec2(2,2)), g.NavId, ImGuiNavHighlightFlags_TypeThin);
}
else
{
// Not navigable into
ItemAdd(bb, 0);
}
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq 0x5e58e0(%rip), %r14 # 0x7b5230
movq 0x1a28(%r14), %r15
testb $0x1, 0xf(%r15)
je 0x1cfa98
cmpw $0x2, 0x88(%r15)
jl 0x1cf97b
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1ce485
movq 0x18(%r15), %rcx
movq %rcx, 0x8(%rsp)
movl 0xa0(%r15), %eax
movd %ecx, %xmm2
shrq $0x20, %rcx
testb $0x1, %al
je 0x1cf9ac
movss 0x38bca5(%rip), %xmm0 # 0x55b644
maxss %xmm2, %xmm0
movss %xmm0, 0x8(%rsp)
movaps %xmm0, %xmm2
movd %ecx, %xmm0
testb $0x2, %al
je 0x1cf9c9
movss 0x38bc88(%rip), %xmm1 # 0x55b644
maxss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movaps %xmm1, %xmm0
unpcklps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movaps %xmm2, 0x10(%rsp)
callq 0x1ce485
movq 0x1a28(%r14), %rax
movsd 0xe0(%rax), %xmm0
movaps 0x10(%rsp), %xmm1
addps %xmm0, %xmm1
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movaps %xmm0, 0x10(%rsp)
movups %xmm0, 0x20(%rsp)
leaq 0x8(%rsp), %rdi
xorps %xmm0, %xmm0
callq 0x1c4891
cmpl $0x0, 0x150(%r15)
jne 0x1cfa1b
cmpb $0x1, 0x159(%r15)
jne 0x1cfa80
testb $-0x80, 0xe(%r15)
jne 0x1cfa80
movl 0x50(%r15), %esi
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1c4a81
movl 0x50(%r15), %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x1c3852
cmpl $0x0, 0x150(%r15)
jne 0x1cfa8e
cmpq 0x1b88(%r14), %r15
jne 0x1cfa8e
movaps 0x10(%rsp), %xmm0
addps 0x38ba2b(%rip), %xmm0 # 0x55b490
leaq 0x30(%rsp), %rdi
movups %xmm0, (%rdi)
movl 0x1b90(%r14), %esi
movl $0x2, %edx
callq 0x1c3852
jmp 0x1cfa8e
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c4a81
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x38cf18(%rip), %rdi # 0x55c9b7
leaq 0x38c33d(%rip), %rsi # 0x55bde3
leaq 0x38cf37(%rip), %rcx # 0x55c9e4
movl $0x1299, %edx # imm = 0x1299
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::BeginChildFrame(unsigned int, ImVec2 const&, int) | bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags extra_flags)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
PushStyleColor(ImGuiCol_ChildBg, style.Colors[ImGuiCol_FrameBg]);
PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);
PushStyleVar(ImGuiStyleVar_ChildBorderSize, style.FrameBorderSize);
PushStyleVar(ImGuiStyleVar_WindowPadding, style.FramePadding);
bool ret = BeginChild(id, size, true, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysUseWindowPadding | extra_flags);
PopStyleVar(3);
PopStyleColor();
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
movq 0x5e5764(%rip), %r15 # 0x7b5230
leaq 0x1688(%r15), %rsi
movl $0x3, %edi
callq 0x1cfb51
movss 0x15a8(%r15), %xmm0
movl $0x6, %edi
callq 0x1cfc7a
movss 0x15ac(%r15), %xmm0
movl $0x7, %edi
callq 0x1cfc7a
addq $0x15a0, %r15 # imm = 0x15A0
movl $0x1, %edi
movq %r15, %rsi
callq 0x1cfe06
orl $0x10004, %ebx # imm = 0x10004
movl %ebp, %edi
movq %r14, %rsi
movl $0x1, %edx
movl %ebx, %ecx
callq 0x1cf905
movl %eax, %ebx
movl $0x3, %edi
callq 0x1cff8c
movl $0x1, %edi
callq 0x1d0068
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::PushStyleColor(int, ImVec4 const&) | void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col)
{
ImGuiContext& g = *GImGui;
ImGuiColorMod backup;
backup.Col = idx;
backup.BackupValue = g.Style.Colors[idx];
g.ColorModifiers.push_back(backup);
g.Style.Colors[idx] = col;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq 0x5e56c5(%rip), %r15 # 0x7b5230
movslq %edi, %rax
shlq $0x4, %rax
leaq (%r15,%rax), %r12
addq $0x1618, %r12 # imm = 0x1618
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movl 0x1b38(%r15), %eax
cmpl 0x1b3c(%r15), %eax
jne 0x1cfbab
leal 0x1(%rax), %r13d
testl %eax, %eax
je 0x1cfbb7
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x1cfbbc
movq 0x1b40(%r15), %r14
jmp 0x1cfc48
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
incl 0x3c0(%r15)
movq 0x5e5664(%rip), %rsi # 0x7b5240
callq *0x5dcf2e(%rip) # 0x7acb10
movq %rax, %r14
movq 0x1b40(%r15), %rsi
testq %rsi, %rsi
je 0x1cfc33
movslq 0x1b38(%r15), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rdi
callq 0x1a5110
movq 0x1b40(%r15), %rdi
testq %rdi, %rdi
je 0x1cfc26
movq 0x5e5615(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1cfc26
decl 0x3c0(%rax)
movq 0x5e5613(%rip), %rsi # 0x7b5240
callq *0x5dcee5(%rip) # 0x7acb18
movq %r14, 0x1b40(%r15)
movl %r13d, 0x1b3c(%r15)
movl 0x1b38(%r15), %eax
cltq
leaq (%rax,%rax,4), %rax
movl %ebp, (%r14,%rax,4)
movaps (%rsp), %xmm0
movups %xmm0, 0x4(%r14,%rax,4)
incl 0x1b38(%r15)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::CalcItemSize(ImVec2, float, float) | ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_w, float default_h)
{
ImGuiWindow* window = GImGui->CurrentWindow;
ImVec2 region_max;
if (size.x < 0.0f || size.y < 0.0f)
region_max = GetContentRegionMaxAbs();
if (size.x == 0.0f)
size.x = default_w;
else if (size.x < 0.0f)
size.x = ImMax(4.0f, region_max.x - window->DC.CursorPos.x + size.x);
if (size.y == 0.0f)
size.y = default_h;
else if (size.y < 0.0f)
size.y = ImMax(4.0f, region_max.y - window->DC.CursorPos.y + size.y);
return size;
} | movq 0x5e3cfc(%rip), %rax # 0x7b5230
movq 0x1a28(%rax), %rax
xorps %xmm4, %xmm4
ucomiss %xmm0, %xmm4
ja 0x1d1552
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
xorps %xmm3, %xmm3
ucomiss %xmm5, %xmm4
jbe 0x1d1570
movsd 0x258(%rax), %xmm3
cmpq $0x0, 0x1f8(%rax)
je 0x1d1570
movss 0x238(%rax), %xmm4
movss %xmm4, %xmm3 # xmm3 = xmm4[0],xmm3[1,2,3]
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm0
jne 0x1d157a
jnp 0x1d159e
ucomiss %xmm0, %xmm4
jbe 0x1d15a2
movss 0xe0(%rax), %xmm1
movaps %xmm3, %xmm4
subss %xmm1, %xmm4
addss %xmm0, %xmm4
movss 0x38a0aa(%rip), %xmm1 # 0x55b644
maxss %xmm4, %xmm1
movss %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1,2,3]
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1 # xmm1 = xmm1[1,1],xmm0[1,1]
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm1
jne 0x1d15b3
jnp 0x1d15d4
ucomiss %xmm1, %xmm4
jbe 0x1d15de
shufps $0x55, %xmm3, %xmm3 # xmm3 = xmm3[1,1,1,1]
subss 0xe4(%rax), %xmm3
addss %xmm3, %xmm1
movss 0x38a074(%rip), %xmm2 # 0x55b644
maxss %xmm1, %xmm2
movlhps %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm2 # xmm2 = xmm2[2,0],xmm0[2,3]
movaps %xmm2, %xmm0
retq
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::SetKeyboardFocusHere(int) | void ImGui::SetKeyboardFocusHere(int offset)
{
IM_ASSERT(offset >= -1); // -1 is allowed but not below
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
g.FocusRequestNextWindow = window;
g.FocusRequestNextCounterAll = window->DC.FocusCounterAll + 1 + offset;
g.FocusRequestNextCounterTab = INT_MAX;
} | cmpl $-0x2, %edi
jle 0x1d258e
movq 0x5e2ccb(%rip), %rax # 0x7b5230
movq 0x1a28(%rax), %rcx
movq %rcx, 0x1cc8(%rax)
movl 0x188(%rcx), %ecx
addl %edi, %ecx
incl %ecx
movl %ecx, 0x1cd8(%rax)
movl $0x7fffffff, 0x1cdc(%rax) # imm = 0x7FFFFFFF
retq
pushq %rax
leaq 0x38ac8a(%rip), %rdi # 0x55d220
leaq 0x389846(%rip), %rsi # 0x55bde3
leaq 0x38ac89(%rip), %rcx # 0x55d22d
movl $0x1b26, %edx # imm = 0x1B26
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::SetItemDefaultFocus() | void ImGui::SetItemDefaultFocus()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (!window->Appearing)
return;
if (g.NavWindow == window->RootWindowForNav && (g.NavInitRequest || g.NavInitResultId != 0) && g.NavLayer == g.NavWindow->DC.NavLayerCurrent)
{
g.NavInitRequest = false;
g.NavInitResultId = g.NavWindow->DC.LastItemId;
g.NavInitResultRectRel = ImRect(g.NavWindow->DC.LastItemRect.Min - g.NavWindow->Pos, g.NavWindow->DC.LastItemRect.Max - g.NavWindow->Pos);
NavUpdateAnyRequestFlag();
if (!IsItemVisible())
SetScrollHereY();
}
} | pushq %r14
pushq %rbx
pushq %rax
movq 0x5e2c77(%rip), %r14 # 0x7b5230
movq 0x1a28(%r14), %rbx
cmpb $0x1, 0x84(%rbx)
jne 0x1d25d9
movq 0x1b88(%r14), %rax
cmpq 0x380(%rbx), %rax
je 0x1d25e1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x0, 0x1c01(%r14)
jne 0x1d25f5
cmpl $0x0, 0x1c04(%r14)
je 0x1d25d9
movl 0x1bf4(%r14), %ecx
cmpl 0x148(%rax), %ecx
jne 0x1d25d9
movb $0x0, 0x1c01(%r14)
movl 0x120(%rax), %ecx
movl %ecx, 0x1c04(%r14)
movsd 0x10(%rax), %xmm0
movsd 0x128(%rax), %xmm1
movsd 0x130(%rax), %xmm2
subps %xmm0, %xmm1
subps %xmm0, %xmm2
movlhps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
movups %xmm1, 0x1c08(%r14)
movb 0x1c19(%r14), %al
movb %al, 0x1c00(%r14)
callq 0x1cf5b2
testb %al, %al
jne 0x1d25d9
movss 0xec(%rbx), %xmm2
subss 0x14(%rbx), %xmm2
xorps %xmm3, %xmm3
mulss 0x15b4(%r14), %xmm3
addss %xmm3, %xmm3
movss 0x388f41(%rip), %xmm1 # 0x55b5bc
movss 0x10c(%rbx), %xmm0
mulss %xmm1, %xmm0
addss %xmm3, %xmm0
addss %xmm2, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d33d7
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::ClosePopupToLevel(int, bool) | void ImGui::ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(remaining >= 0 && remaining < g.OpenPopupStack.Size);
ImGuiWindow* focus_window = g.OpenPopupStack[remaining].SourceWindow;
ImGuiWindow* popup_window = g.OpenPopupStack[remaining].Window;
g.OpenPopupStack.resize(remaining);
if (restore_focus_to_window_under_popup)
{
if (focus_window && !focus_window->WasActive && popup_window)
{
// Fallback
FocusTopMostWindowUnderOne(popup_window, NULL);
}
else
{
if (g.NavLayer == 0 && focus_window)
focus_window = NavRestoreLastChildNavWindow(focus_window);
FocusWindow(focus_window);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x1d3e48
movl %edi, %r15d
movq 0x5e153e(%rip), %r13 # 0x7b5230
cmpl %edi, 0x1b68(%r13)
jle 0x1d3e48
movl %esi, %ebp
movq 0x1b70(%r13), %rax
movl %r15d, %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rdi
movq 0x10(%rax,%rcx), %rbx
movl 0x1b6c(%r13), %eax
cmpl %r15d, %eax
jge 0x1d3dd6
testl %eax, %eax
movq %rdi, (%rsp)
je 0x1d3d47
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
addl %eax, %r14d
jmp 0x1d3d4d
movl $0x8, %r14d
cmpl %r15d, %r14d
cmovlel %r15d, %r14d
movq %r14, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
incl 0x3c0(%r13)
movq 0x5e14d3(%rip), %rsi # 0x7b5240
callq *0x5d8d9d(%rip) # 0x7acb10
movq %rax, %r12
movq 0x1b70(%r13), %rsi
testq %rsi, %rsi
je 0x1d3dc4
movslq 0x1b68(%r13), %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdx
movq %r12, %rdi
callq 0x1a5110
movq 0x1b70(%r13), %rdi
testq %rdi, %rdi
je 0x1d3db7
movq 0x5e1484(%rip), %rax # 0x7b5230
testq %rax, %rax
je 0x1d3db7
decl 0x3c0(%rax)
movq 0x5e1482(%rip), %rsi # 0x7b5240
callq *0x5d8d54(%rip) # 0x7acb18
movq %r12, 0x1b70(%r13)
movl %r14d, 0x1b6c(%r13)
movq (%rsp), %rdi
movl %r15d, 0x1b68(%r13)
testb %bpl, %bpl
je 0x1d3e0c
testq %rbx, %rbx
je 0x1d3e1b
testq %rdi, %rdi
sete %al
orb 0x7f(%rbx), %al
je 0x1d3e33
cmpl $0x0, 0x1bf4(%r13)
jne 0x1d3e1d
movq 0x388(%rbx), %rax
testq %rax, %rax
cmovneq %rax, %rbx
jmp 0x1d3e1d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c5cfc
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c975c
leaq 0x389612(%rip), %rdi # 0x55d461
leaq 0x387f8d(%rip), %rsi # 0x55bde3
leaq 0x389638(%rip), %rcx # 0x55d495
movl $0x1d7f, %edx # imm = 0x1D7F
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::CloseCurrentPopup() | void ImGui::CloseCurrentPopup()
{
ImGuiContext& g = *GImGui;
int popup_idx = g.BeginPopupStack.Size - 1;
if (popup_idx < 0 || popup_idx >= g.OpenPopupStack.Size || g.BeginPopupStack[popup_idx].PopupId != g.OpenPopupStack[popup_idx].PopupId)
return;
// Closing a menu closes its top-most parent popup (unless a modal)
while (popup_idx > 0)
{
ImGuiWindow* popup_window = g.OpenPopupStack[popup_idx].Window;
ImGuiWindow* parent_popup_window = g.OpenPopupStack[popup_idx - 1].Window;
bool close_parent = false;
if (popup_window && (popup_window->Flags & ImGuiWindowFlags_ChildMenu))
if (parent_popup_window == NULL || !(parent_popup_window->Flags & ImGuiWindowFlags_Modal))
close_parent = true;
if (!close_parent)
break;
popup_idx--;
}
//IMGUI_DEBUG_LOG("CloseCurrentPopup %d -> %d\n", g.BeginPopupStack.Size - 1, popup_idx);
ClosePopupToLevel(popup_idx, true);
// A common pattern is to close a popup when selecting a menu item/selectable that will open another window.
// To improve this usage pattern, we avoid nav highlight for a single frame in the parent window.
// Similarly, we could avoid mouse hover highlight in this window but it is less visually problematic.
if (ImGuiWindow* window = g.NavWindow)
window->DC.NavHideHighlightOneFrame = true;
} | pushq %rbx
movq 0x5e13c1(%rip), %rbx # 0x7b5230
movl 0x1b78(%rbx), %esi
testl %esi, %esi
jle 0x1d3f38
movl 0x1b68(%rbx), %eax
cmpl %eax, %esi
jg 0x1d3f38
leal -0x1(%rsi), %ecx
movq 0x1b70(%rbx), %rdx
movq 0x1b80(%rbx), %rdi
movl %ecx, %r8d
shlq $0x4, %r8
leaq (%r8,%r8,2), %r8
movl (%rdi,%r8), %edi
cmpl (%rdx,%r8), %edi
jne 0x1d3f38
xorl %edi, %edi
cmpl $0x1, %esi
je 0x1d3f1b
leal -0x2(%rsi), %r8d
leaq (%r8,%r8,2), %r8
shlq $0x4, %r8
addq %rdx, %r8
addq $0x8, %r8
leal -0x1(%rsi), %r9d
cmpl %r9d, %eax
jbe 0x1d3f3a
movl %r9d, %r10d
leaq (%r10,%r10,2), %r10
shlq $0x4, %r10
movq 0x8(%rdx,%r10), %r10
testq %r10, %r10
je 0x1d3f17
testb $0x10, 0xf(%r10)
je 0x1d3f13
movq (%r8), %rsi
testq %rsi, %rsi
je 0x1d3f02
testb $0x8, 0xf(%rsi)
jne 0x1d3f13
addq $-0x30, %r8
decl %ecx
movl %r9d, %esi
cmpl $0x1, %r9d
ja 0x1d3ecf
jmp 0x1d3f1b
movl %ecx, %edi
jmp 0x1d3f1b
decl %esi
movl %esi, %edi
movl $0x1, %esi
callq 0x1d3cd5
movq 0x1b88(%rbx), %rax
testq %rax, %rax
je 0x1d3f38
movb $0x1, 0x158(%rax)
popq %rbx
retq
leaq 0x38a5fd(%rip), %rdi # 0x55e53e
leaq 0x38a5ff(%rip), %rsi # 0x55e547
leaq 0x38b7fc(%rip), %rcx # 0x55f74b
movl $0x4de, %edx # imm = 0x4DE
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::BeginPopupModal(char const*, bool*, int) | bool ImGui::BeginPopupModal(const char* name, bool* p_open, ImGuiWindowFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
const ImGuiID id = window->GetID(name);
if (!IsPopupOpen(id))
{
g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
return false;
}
// Center modal windows by default
// FIXME: Should test for (PosCond & window->SetWindowPosAllowFlags) with the upcoming window.
if ((g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasPos) == 0)
SetNextWindowPos(g.IO.DisplaySize * 0.5f, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
flags |= ImGuiWindowFlags_Popup | ImGuiWindowFlags_Modal | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings;
const bool is_open = Begin(name, p_open, flags);
if (!is_open || (p_open && !*p_open)) // NB: is_open can be 'false' when the popup is completely clipped (e.g. zero size display)
{
EndPopup();
if (is_open)
ClosePopupToLevel(g.BeginPopupStack.Size, true);
return false;
}
return is_open;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5e117a(%rip), %r15 # 0x7b5230
movq 0x1a28(%r15), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1c3dc2
movq 0x5e1162(%rip), %rcx # 0x7b5230
movslq 0x1b78(%rcx), %rdx
cmpl %edx, 0x1b68(%rcx)
jle 0x1d4170
movq 0x1b70(%rcx), %rsi
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
cmpl %eax, (%rsi,%rdx)
jne 0x1d4170
testb $0x1, 0x1ac0(%r15)
jne 0x1d4135
movsd 0x10(%r15), %xmm0
mulps 0x3871e4(%rip), %xmm0 # 0x55b2f0
orl $0x1, 0x1ac0(%rcx)
movlps %xmm0, 0x1ad0(%rcx)
movabsq $0x3f0000003f000000, %rax # imm = 0x3F0000003F000000
movq %rax, 0x1ad8(%rcx)
movl $0x8, 0x1ac4(%rcx)
orl $0xc000120, %ebp # imm = 0xC000120
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1c986f
testb %al, %al
je 0x1d4188
movb $0x1, %al
testq %rbx, %rbx
je 0x1d417d
cmpb $0x0, (%rbx)
jne 0x1d417d
callq 0x1d3fee
movl 0x1b78(%r15), %edi
movl $0x1, %esi
callq 0x1d3cd5
jmp 0x1d417b
movl $0x0, 0x1ac0(%r15)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d3fee
jmp 0x1d417b
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::FindBestWindowPosForPopupEx(ImVec2 const&, ImVec2 const&, int*, ImRect const&, ImRect const&, ImGuiPopupPositionPolicy) | ImVec2 ImGui::FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const ImVec2& size, ImGuiDir* last_dir, const ImRect& r_outer, const ImRect& r_avoid, ImGuiPopupPositionPolicy policy)
{
ImVec2 base_pos_clamped = ImClamp(ref_pos, r_outer.Min, r_outer.Max - size);
//GetForegroundDrawList()->AddRect(r_avoid.Min, r_avoid.Max, IM_COL32(255,0,0,255));
//GetForegroundDrawList()->AddRect(r_outer.Min, r_outer.Max, IM_COL32(0,255,0,255));
// Combo Box policy (we want a connecting edge)
if (policy == ImGuiPopupPositionPolicy_ComboBox)
{
const ImGuiDir dir_prefered_order[ImGuiDir_COUNT] = { ImGuiDir_Down, ImGuiDir_Right, ImGuiDir_Left, ImGuiDir_Up };
for (int n = (*last_dir != ImGuiDir_None) ? -1 : 0; n < ImGuiDir_COUNT; n++)
{
const ImGuiDir dir = (n == -1) ? *last_dir : dir_prefered_order[n];
if (n != -1 && dir == *last_dir) // Already tried this direction?
continue;
ImVec2 pos;
if (dir == ImGuiDir_Down) pos = ImVec2(r_avoid.Min.x, r_avoid.Max.y); // Below, Toward Right (default)
if (dir == ImGuiDir_Right) pos = ImVec2(r_avoid.Min.x, r_avoid.Min.y - size.y); // Above, Toward Right
if (dir == ImGuiDir_Left) pos = ImVec2(r_avoid.Max.x - size.x, r_avoid.Max.y); // Below, Toward Left
if (dir == ImGuiDir_Up) pos = ImVec2(r_avoid.Max.x - size.x, r_avoid.Min.y - size.y); // Above, Toward Left
if (!r_outer.Contains(ImRect(pos, pos + size)))
continue;
*last_dir = dir;
return pos;
}
}
// Default popup policy
const ImGuiDir dir_prefered_order[ImGuiDir_COUNT] = { ImGuiDir_Right, ImGuiDir_Down, ImGuiDir_Up, ImGuiDir_Left };
for (int n = (*last_dir != ImGuiDir_None) ? -1 : 0; n < ImGuiDir_COUNT; n++)
{
const ImGuiDir dir = (n == -1) ? *last_dir : dir_prefered_order[n];
if (n != -1 && dir == *last_dir) // Already tried this direction?
continue;
float avail_w = (dir == ImGuiDir_Left ? r_avoid.Min.x : r_outer.Max.x) - (dir == ImGuiDir_Right ? r_avoid.Max.x : r_outer.Min.x);
float avail_h = (dir == ImGuiDir_Up ? r_avoid.Min.y : r_outer.Max.y) - (dir == ImGuiDir_Down ? r_avoid.Max.y : r_outer.Min.y);
if (avail_w < size.x || avail_h < size.y)
continue;
ImVec2 pos;
pos.x = (dir == ImGuiDir_Left) ? r_avoid.Min.x - size.x : (dir == ImGuiDir_Right) ? r_avoid.Max.x : base_pos_clamped.x;
pos.y = (dir == ImGuiDir_Up) ? r_avoid.Min.y - size.y : (dir == ImGuiDir_Down) ? r_avoid.Max.y : base_pos_clamped.y;
*last_dir = dir;
return pos;
}
// Fallback, try to keep within display
*last_dir = ImGuiDir_None;
ImVec2 pos = ref_pos;
pos.x = ImMax(ImMin(pos.x + size.x, r_outer.Max.x) - size.x, r_outer.Min.x);
pos.y = ImMax(ImMin(pos.y + size.y, r_outer.Max.y) - size.y, r_outer.Min.y);
return pos;
} | pushq %rbx
movsd (%rcx), %xmm1
movsd 0x8(%rcx), %xmm4
movsd (%rsi), %xmm2
movaps %xmm1, %xmm15
shufps $0x55, %xmm1, %xmm15 # xmm15 = xmm15[1,1],xmm1[1,1]
movsd (%rdi), %xmm3
movaps %xmm4, %xmm11
subps %xmm2, %xmm11
movaps %xmm3, %xmm12
shufps $0x55, %xmm3, %xmm12 # xmm12 = xmm12[1,1],xmm3[1,1]
movaps %xmm11, %xmm0
cmpltps %xmm3, %xmm0
unpcklps %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %eax
testb $0x2, %al
jne 0x1d4679
movaps %xmm12, %xmm5
jmp 0x1d4682
movaps %xmm11, %xmm5
shufps $0x55, %xmm11, %xmm5 # xmm5 = xmm5[1,1],xmm11[1,1]
testb $0x1, %al
jne 0x1d468a
movaps %xmm3, %xmm11
movl (%rdx), %eax
movss (%r8), %xmm7
movaps %xmm2, %xmm6
shufps $0x55, %xmm2, %xmm6 # xmm6 = xmm6[1,1],xmm2[1,1]
cmpl $0x1, %r9d
jne 0x1d47be
movaps %xmm5, -0x40(%rsp)
xorl %r9d, %r9d
xorl %ecx, %ecx
cmpl $-0x1, %eax
setne %r9b
sete %cl
movss 0x4(%r8), %xmm9
movss 0x8(%r8), %xmm8
movaps %xmm8, %xmm13
subss %xmm2, %xmm13
movaps %xmm9, %xmm0
subss %xmm6, %xmm0
movaps %xmm13, %xmm5
unpcklps %xmm0, %xmm5 # xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1]
movaps %xmm5, -0x10(%rsp)
movss 0xc(%r8), %xmm10
unpcklps %xmm10, %xmm13 # xmm13 = xmm13[0],xmm10[0],xmm13[1],xmm10[1]
movaps %xmm7, %xmm5
unpcklps %xmm0, %xmm5 # xmm5 = xmm5[0],xmm0[0],xmm5[1],xmm0[1]
movaps %xmm5, -0x20(%rsp)
movaps %xmm7, %xmm0
unpcklps %xmm10, %xmm0 # xmm0 = xmm0[0],xmm10[0],xmm0[1],xmm10[1]
movaps %xmm0, -0x30(%rsp)
shll $0x2, %r9d
leaq 0x386e95(%rip), %rsi # 0x55b5a0
subq %r9, %rsi
leaq 0x386ffb(%rip), %r9 # 0x55b710
movq %rdx, %r10
testq %rcx, %rcx
cmovneq %rsi, %r10
movl (%r10), %r10d
je 0x1d4729
cmpl %eax, %r10d
je 0x1d47a6
cmpl $0x3, %r10d
ja 0x1d475a
movl %r10d, %r11d
movslq (%r9,%r11,4), %r11
addq %r9, %r11
jmpq *%r11
movaps %xmm13, %xmm14
jmp 0x1d475e
movaps -0x10(%rsp), %xmm14
jmp 0x1d475e
movaps -0x30(%rsp), %xmm14
jmp 0x1d475e
movaps -0x20(%rsp), %xmm14
jmp 0x1d475e
xorps %xmm14, %xmm14
movaps %xmm14, %xmm0
shufps $0x55, %xmm14, %xmm0 # xmm0 = xmm0[1,1],xmm14[1,1]
movaps %xmm15, %xmm5
cmpleps %xmm0, %xmm5
movaps %xmm1, %xmm0
cmpleps %xmm14, %xmm0
andps %xmm5, %xmm0
movd %xmm0, %r11d
movaps %xmm2, %xmm0
addps %xmm14, %xmm0
cmpleps %xmm4, %xmm0
unpcklps %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
movmskpd %xmm0, %ebx
andl %ebx, %r11d
andb $0x2, %bl
shrb %bl
andb %bl, %r11b
cmpb $0x1, %r11b
je 0x1d48b1
incq %rcx
addq $0x4, %rsi
cmpq $0x5, %rcx
jne 0x1d4715
movaps -0x40(%rsp), %xmm5
jmp 0x1d47d0
movss 0x4(%r8), %xmm9
movss 0x8(%r8), %xmm8
movss 0xc(%r8), %xmm10
cmpltss %xmm15, %xmm12
movaps %xmm12, %xmm0
andnps %xmm5, %xmm0
andps %xmm15, %xmm12
orps %xmm0, %xmm12
movaps %xmm12, %xmm14
cmpltss %xmm1, %xmm3
movaps %xmm3, %xmm0
andnps %xmm11, %xmm0
andps %xmm1, %xmm3
orps %xmm0, %xmm3
xorl %ecx, %ecx
xorl %esi, %esi
cmpl $-0x1, %eax
setne %cl
sete %sil
movaps %xmm4, %xmm11
shufps $0x55, %xmm4, %xmm11 # xmm11 = xmm11[1,1],xmm4[1,1]
shll $0x2, %ecx
leaq 0x38b2b4(%rip), %r9 # 0x55fad0
subq %rcx, %r9
movq %rdx, %rcx
testq %rsi, %rsi
cmovneq %r9, %rcx
movl (%rcx), %ecx
je 0x1d4831
cmpl %eax, %ecx
je 0x1d487a
movaps %xmm7, %xmm12
testl %ecx, %ecx
je 0x1d483d
movaps %xmm4, %xmm12
movaps %xmm8, %xmm13
cmpl $0x1, %ecx
je 0x1d484a
movaps %xmm1, %xmm13
subss %xmm13, %xmm12
ucomiss %xmm12, %xmm2
ja 0x1d487a
movaps %xmm9, %xmm12
cmpl $0x2, %ecx
je 0x1d4862
movaps %xmm11, %xmm12
movaps %xmm10, %xmm13
cmpl $0x3, %ecx
je 0x1d486f
movaps %xmm15, %xmm13
subss %xmm13, %xmm12
ucomiss %xmm12, %xmm6
jbe 0x1d48b6
incq %rsi
addq $0x4, %r9
cmpq $0x5, %rsi
jne 0x1d481f
movl $0xffffffff, (%rdx) # imm = 0xFFFFFFFF
movsd (%rdi), %xmm0
addps %xmm2, %xmm0
minps %xmm4, %xmm0
subps %xmm2, %xmm0
movaps %xmm1, %xmm14
cmpleps %xmm0, %xmm14
andps %xmm14, %xmm0
andnps %xmm1, %xmm14
orps %xmm0, %xmm14
jmp 0x1d48f3
movl %r10d, (%rdx)
jmp 0x1d48f3
testl %ecx, %ecx
je 0x1d48d8
cmpl $0x1, %ecx
je 0x1d48e0
xorps %xmm1, %xmm1
movss %xmm3, %xmm1 # xmm1 = xmm3[0],xmm1[1,2,3]
cmpl $0x2, %ecx
jne 0x1d48f9
movss 0x4(%r8), %xmm14
subss %xmm6, %xmm14
jmp 0x1d48e8
subss %xmm2, %xmm7
movaps %xmm7, %xmm8
xorps %xmm1, %xmm1
movss %xmm8, %xmm1 # xmm1 = xmm8[0],xmm1[1,2,3]
movlhps %xmm1, %xmm14 # xmm14 = xmm14[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm14 # xmm14 = xmm14[2,0],xmm1[2,3]
movl %ecx, (%rdx)
movaps %xmm14, %xmm0
popq %rbx
retq
cmpl $0x3, %ecx
jne 0x1d48e8
movss 0xc(%r8), %xmm14
jmp 0x1d48e8
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::BeginDragDropSource(int) | bool ImGui::BeginDragDropSource(ImGuiDragDropFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
bool source_drag_active = false;
ImGuiID source_id = 0;
ImGuiID source_parent_id = 0;
int mouse_button = 0;
if (!(flags & ImGuiDragDropFlags_SourceExtern))
{
source_id = window->DC.LastItemId;
if (source_id != 0 && g.ActiveId != source_id) // Early out for most common case
return false;
if (g.IO.MouseDown[mouse_button] == false)
return false;
if (source_id == 0)
{
// If you want to use BeginDragDropSource() on an item with no unique identifier for interaction, such as Text() or Image(), you need to:
// A) Read the explanation below, B) Use the ImGuiDragDropFlags_SourceAllowNullID flag, C) Swallow your programmer pride.
if (!(flags & ImGuiDragDropFlags_SourceAllowNullID))
{
IM_ASSERT(0);
return false;
}
// Early out
if ((window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HoveredRect) == 0 && (g.ActiveId == 0 || g.ActiveIdWindow != window))
return false;
// Magic fallback (=somehow reprehensible) to handle items with no assigned ID, e.g. Text(), Image()
// We build a throwaway ID based on current ID stack + relative AABB of items in window.
// THE IDENTIFIER WON'T SURVIVE ANY REPOSITIONING OF THE WIDGET, so if your widget moves your dragging operation will be canceled.
// We don't need to maintain/call ClearActiveID() as releasing the button will early out this function and trigger !ActiveIdIsAlive.
source_id = window->DC.LastItemId = window->GetIDFromRectangle(window->DC.LastItemRect);
bool is_hovered = ItemHoverable(window->DC.LastItemRect, source_id);
if (is_hovered && g.IO.MouseClicked[mouse_button])
{
SetActiveID(source_id, window);
FocusWindow(window);
}
if (g.ActiveId == source_id) // Allow the underlying widget to display/return hovered during the mouse release frame, else we would get a flicker.
g.ActiveIdAllowOverlap = is_hovered;
}
else
{
g.ActiveIdAllowOverlap = false;
}
if (g.ActiveId != source_id)
return false;
source_parent_id = window->IDStack.back();
source_drag_active = IsMouseDragging(mouse_button);
}
else
{
window = NULL;
source_id = ImHashStr("#SourceExtern");
source_drag_active = true;
}
if (source_drag_active)
{
if (!g.DragDropActive)
{
IM_ASSERT(source_id != 0);
ClearDragDrop();
ImGuiPayload& payload = g.DragDropPayload;
payload.SourceId = source_id;
payload.SourceParentId = source_parent_id;
g.DragDropActive = true;
g.DragDropSourceFlags = flags;
g.DragDropMouseButton = mouse_button;
}
g.DragDropSourceFrameCount = g.FrameCount;
g.DragDropWithinSourceOrTarget = true;
if (!(flags & ImGuiDragDropFlags_SourceNoPreviewTooltip))
{
// Target can request the Source to not display its tooltip (we use a dedicated flag to make this request explicit)
// We unfortunately can't just modify the source flags and skip the call to BeginTooltip, as caller may be emitting contents.
BeginTooltip();
if (g.DragDropAcceptIdPrev && (g.DragDropAcceptFlags & ImGuiDragDropFlags_AcceptNoPreviewTooltip))
{
ImGuiWindow* tooltip_window = g.CurrentWindow;
tooltip_window->SkipItems = true;
tooltip_window->HiddenFramesCanSkipItems = 1;
}
}
if (!(flags & ImGuiDragDropFlags_SourceNoDisableHover) && !(flags & ImGuiDragDropFlags_SourceExtern))
window->DC.LastItemStatusFlags &= ~ImGuiItemStatusFlags_HoveredRect;
return true;
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movq 0x5e04ad(%rip), %r12 # 0x7b5230
testb $0x10, %bl
jne 0x1d4dc4
movq 0x1a28(%r12), %r14
movl 0x120(%r14), %ebp
testl %ebp, %ebp
je 0x1d4e8c
cmpl %ebp, 0x1a70(%r12)
jne 0x1d4f58
xorl %r15d, %r15d
cmpb $0x0, 0x138(%r12)
jne 0x1d4f1e
jmp 0x1d4f5b
leaq 0x38896a(%rip), %rdi # 0x55d735
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x1c0da0
movl %eax, %ebp
xorl %r15d, %r15d
cmpb $0x0, 0x1e9c(%r12)
jne 0x1d4e21
testl %ebp, %ebp
je 0x1d4f78
callq 0x1ce757
movl %ebp, 0x1ebc(%r12)
movl %r15d, 0x1ec0(%r12)
movb $0x1, 0x1e9c(%r12)
movl %ebx, 0x1ea0(%r12)
movl $0x0, 0x1ea8(%r12)
movl 0x19c0(%r12), %eax
movl %eax, 0x1ea4(%r12)
movb $0x1, 0x1e9d(%r12)
testb $0x1, %bl
jne 0x1d4e73
callq 0x1d35d3
cmpl $0x0, 0x1f10(%r12)
je 0x1d4e73
testb $0x10, 0x1f05(%r12)
je 0x1d4e73
movq 0x1a28(%r12), %rax
movb $0x1, 0x83(%rax)
movl $0x1, 0xa8(%rax)
movb $0x1, %r15b
testb $0x12, %bl
jne 0x1d4f5b
andb $-0x2, 0x124(%r14)
jmp 0x1d4f5b
cmpb $0x0, 0x138(%r12)
je 0x1d4f58
testb $0x8, %bl
je 0x1d4fb6
testb $0x1, 0x124(%r14)
jne 0x1d4ecb
cmpl $0x0, 0x1a70(%r12)
je 0x1d4f58
cmpq %r14, 0x1a98(%r12)
jne 0x1d4f58
leaq 0x128(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c421a
movl %eax, %ebp
movl %eax, 0x120(%r14)
movq %r15, %rdi
movl %eax, %esi
callq 0x1c502e
movl %eax, %r15d
testb %al, %al
je 0x1d4f14
cmpb $0x1, 0x428(%r12)
jne 0x1d4f14
movl %ebp, %edi
movq %r14, %rsi
callq 0x1c4657
movq %r14, %rdi
callq 0x1c5cfc
cmpl %ebp, 0x1a70(%r12)
jne 0x1d4f58
movb %r15b, 0x1a7d(%r12)
movslq 0xd0(%r14), %rax
testq %rax, %rax
jle 0x1d4f97
movq 0x5e02f7(%rip), %rcx # 0x7b5230
cmpb $0x0, 0x138(%rcx)
je 0x1d4f58
movss 0x38(%rcx), %xmm0
movss 0x494(%rcx), %xmm1
mulss %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jae 0x1d4f67
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xd8(%r14), %rcx
movl -0x4(%rcx,%rax,4), %r15d
jmp 0x1d4ddc
leaq 0x3887c4(%rip), %rdi # 0x55d743
leaq 0x386e5d(%rip), %rsi # 0x55bde3
leaq 0x388774(%rip), %rcx # 0x55d701
movl $0x22d5, %edx # imm = 0x22D5
callq 0x1a5270
leaq 0x393d33(%rip), %rdi # 0x568cd1
leaq 0x3895a2(%rip), %rsi # 0x55e547
leaq 0x38a60c(%rip), %rcx # 0x55f5b8
movl $0x4e8, %edx # imm = 0x4E8
callq 0x1a5270
leaq 0x401092(%rip), %rdi # 0x5d604f
leaq 0x386e1f(%rip), %rsi # 0x55bde3
leaq 0x388736(%rip), %rcx # 0x55d701
movl $0x22ab, %edx # imm = 0x22AB
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::BeginDragDropTargetCustom(ImRect const&, unsigned int) | bool ImGui::BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id)
{
ImGuiContext& g = *GImGui;
if (!g.DragDropActive)
return false;
ImGuiWindow* window = g.CurrentWindow;
if (g.HoveredWindow == NULL || window->RootWindow != g.HoveredWindow->RootWindow)
return false;
IM_ASSERT(id != 0);
if (!IsMouseHoveringRect(bb.Min, bb.Max) || (id == g.DragDropPayload.SourceId))
return false;
if (window->SkipItems)
return false;
IM_ASSERT(g.DragDropWithinSourceOrTarget == false);
g.DragDropTargetRect = bb;
g.DragDropTargetId = id;
g.DragDropWithinSourceOrTarget = true;
return true;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x5dfece(%rip), %r15 # 0x7b5230
cmpb $0x1, 0x1e9c(%r15)
jne 0x1d53bf
movq 0x1a30(%r15), %rax
testq %rax, %rax
je 0x1d53bf
movq 0x1a28(%r15), %r12
movq 0x370(%r12), %rcx
cmpq 0x370(%rax), %rcx
jne 0x1d53bf
movl %esi, %ebx
testl %esi, %esi
je 0x1d53f6
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
movl $0x1, %edx
callq 0x1c4e52
testb %al, %al
je 0x1d53bf
cmpl %ebx, 0x1ebc(%r15)
je 0x1d53bf
cmpb $0x0, 0x83(%r12)
je 0x1d53cd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x0, 0x1e9d(%r15)
jne 0x1d5415
movups (%r14), %xmm0
movups %xmm0, 0x1ef0(%r15)
movl %ebx, 0x1f00(%r15)
movb $0x1, 0x1e9d(%r15)
movb $0x1, %al
jmp 0x1d53c1
leaq 0x38834d(%rip), %rdi # 0x55d74a
leaq 0x3869df(%rip), %rsi # 0x55bde3
leaq 0x38851b(%rip), %rcx # 0x55d926
movl $0x233a, %edx # imm = 0x233A
callq 0x1a5270
leaq 0x388549(%rip), %rdi # 0x55d965
leaq 0x3869c0(%rip), %rsi # 0x55bde3
leaq 0x3884fc(%rip), %rcx # 0x55d926
movl $0x2340, %edx # imm = 0x2340
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
ImGui::AcceptDragDropPayload(char const*, int) | const ImGuiPayload* ImGui::AcceptDragDropPayload(const char* type, ImGuiDragDropFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiPayload& payload = g.DragDropPayload;
IM_ASSERT(g.DragDropActive); // Not called between BeginDragDropTarget() and EndDragDropTarget() ?
IM_ASSERT(payload.DataFrameCount != -1); // Forgot to call EndDragDropTarget() ?
if (type != NULL && !payload.IsDataType(type))
return NULL;
// Accept smallest drag target bounding box, this allows us to nest drag targets conveniently without ordering constraints.
// NB: We currently accept NULL id as target. However, overlapping targets requires a unique ID to function!
const bool was_accepted_previously = (g.DragDropAcceptIdPrev == g.DragDropTargetId);
ImRect r = g.DragDropTargetRect;
float r_surface = r.GetWidth() * r.GetHeight();
if (r_surface < g.DragDropAcceptIdCurrRectSurface)
{
g.DragDropAcceptFlags = flags;
g.DragDropAcceptIdCurr = g.DragDropTargetId;
g.DragDropAcceptIdCurrRectSurface = r_surface;
}
// Render default drop visuals
payload.Preview = was_accepted_previously;
flags |= (g.DragDropSourceFlags & ImGuiDragDropFlags_AcceptNoDrawDefaultRect); // Source can also inhibit the preview (useful for external sources that lives for 1 frame)
if (!(flags & ImGuiDragDropFlags_AcceptNoDrawDefaultRect) && payload.Preview)
{
// FIXME-DRAG: Settle on a proper default visuals for drop target.
r.Expand(3.5f);
bool push_clip_rect = !window->ClipRect.Contains(r);
if (push_clip_rect) window->DrawList->PushClipRect(r.Min-ImVec2(1,1), r.Max+ImVec2(1,1));
window->DrawList->AddRect(r.Min, r.Max, GetColorU32(ImGuiCol_DragDropTarget), 0.0f, ~0, 2.0f);
if (push_clip_rect) window->DrawList->PopClipRect();
}
g.DragDropAcceptFrameCount = g.FrameCount;
payload.Delivery = was_accepted_previously && !IsMouseDown(g.DragDropMouseButton); // For extern drag sources affecting os window focus, it's easier to just test !IsMouseDown() instead of IsMouseReleased()
if (!payload.Delivery && !(flags & ImGuiDragDropFlags_AcceptBeforeDelivery))
return NULL;
return &payload;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x5dfd0d(%rip), %rbx # 0x7b5230
cmpb $0x0, 0x1e9c(%rbx)
je 0x1d5745
cmpl $-0x1, 0x1ec4(%rbx)
je 0x1d5764
movl %esi, %ebp
movq 0x1a28(%rbx), %r12
testq %rdi, %rdi
je 0x1d555f
leaq 0x1ec8(%rbx), %rsi
callq 0x1a5f30
testl %eax, %eax
jne 0x1d571b
movl 0x1f00(%rbx), %r13d
movl 0x1f10(%rbx), %r14d
cmpl %r13d, %r14d
sete %al
movups 0x1ef0(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movaps %xmm1, %xmm3
subps %xmm0, %xmm3
movaps %xmm3, %xmm2
shufps $0x55, %xmm3, %xmm2 # xmm2 = xmm2[1,1],xmm3[1,1]
mulss %xmm3, %xmm2
movss 0x1f08(%rbx), %xmm3
ucomiss %xmm2, %xmm3
jbe 0x1d55be
movl %ebp, 0x1f04(%rbx)
movl %r13d, 0x1f0c(%rbx)
movss %xmm2, 0x1f08(%rbx)
movl %r14d, %ecx
xorl %r13d, %ecx
movb %al, 0x1ee9(%rbx)
movl 0x1ea0(%rbx), %eax
orl %ebp, %eax
andl $0x800, %eax # imm = 0x800
orl %ecx, %eax
jne 0x1d56d7
leaq 0x18(%rsp), %rax
addps 0x385ef5(%rip), %xmm0 # 0x55b4e0
addps 0x385efe(%rip), %xmm1 # 0x55b4f0
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movaps %xmm2, -0x8(%rax)
ucomiss 0x240(%r12), %xmm0
jb 0x1d5644
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2 # xmm2 = xmm2[1,1],xmm0[1,1]
ucomiss 0x244(%r12), %xmm2
jb 0x1d5644
movss 0x248(%r12), %xmm2
ucomiss %xmm1, %xmm2
jb 0x1d5644
movss 0x24c(%r12), %xmm2
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3 # xmm3 = xmm3[1,1],xmm1[1,1]
movb $0x1, %r15b
ucomiss %xmm3, %xmm2
movq %rbx, %rax
jae 0x1d566b
movq 0x2b8(%r12), %rdi
addps 0x385cfd(%rip), %xmm0 # 0x55b350
addps 0x385c76(%rip), %xmm1 # 0x55b2d0
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1f8b08
movq 0x5dfbc5(%rip), %rax # 0x7b5230
movl %r15d, 0xc(%rsp)
movq 0x2b8(%r12), %r15
movups 0x18c8(%rax), %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movss 0x1568(%rax), %xmm0
mulss 0xc(%rdi), %xmm0
movss %xmm0, 0xc(%rdi)
callq 0x1c12b7
leaq 0x10(%rsp), %rsi
movss 0x385f59(%rip), %xmm1 # 0x55b604
xorps %xmm0, %xmm0
movq %r15, %rdi
leaq 0x18(%rsp), %rdx
movl %eax, %ecx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
callq 0x1faba0
cmpb $0x0, 0xc(%rsp)
jne 0x1d56d7
movq 0x2b8(%r12), %rdi
callq 0x1f8c84
movl 0x19c0(%rbx), %eax
movl %eax, 0x1f14(%rbx)
cmpl %r13d, %r14d
jne 0x1d571f
movl 0x1ea8(%rbx), %eax
cmpq $0x5, %rax
jae 0x1d5783
movq 0x5dfb31(%rip), %rcx # 0x7b5230
movb 0x138(%rcx,%rax), %al
movl %eax, %ecx
xorb $0x1, %cl
movb %cl, 0x1eea(%rbx)
btl $0xa, %ebp
jb 0x1d572c
testb %al, %al
je 0x1d572c
xorl %ebx, %ebx
jmp 0x1d5733
movb $0x0, 0x1eea(%rbx)
btl $0xa, %ebp
jae 0x1d571b
addq $0x1eb0, %rbx # imm = 0x1EB0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3868b2(%rip), %rdi # 0x55bffe
leaq 0x386690(%rip), %rsi # 0x55bde3
leaq 0x388255(%rip), %rcx # 0x55d9af
movl $0x2370, %edx # imm = 0x2370
callq 0x1a5270
leaq 0x388297(%rip), %rdi # 0x55da02
leaq 0x386671(%rip), %rsi # 0x55bde3
leaq 0x388236(%rip), %rcx # 0x55d9af
movl $0x2371, %edx # imm = 0x2371
callq 0x1a5270
leaq 0x387024(%rip), %rdi # 0x55c7ae
leaq 0x386652(%rip), %rsi # 0x55bde3
leaq 0x387066(%rip), %rcx # 0x55c7fe
movl $0x1154, %edx # imm = 0x1154
callq 0x1a5270
| /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.