name string | code string | asm string | file string |
|---|---|---|---|
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... | 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 0x... | /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;
Inte... | 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
... | /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;
Intege... | 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
imul... | /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 /* VER... | 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
j... | /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);
... | 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,... | /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;
... | 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)) {
... | 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 %ea... | /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);
... | 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 $... | /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_d... | 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(... | /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_da... | 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-... | 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(%... | /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));
... | 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 (%... | /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)... | 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
t... | /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) { ... | 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, ... | /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(... | 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 # ... | /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)... | 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
... | /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 (chu... | 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
... | /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... | 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 ... | /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 -= byte... | 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... | /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; lo... | 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
... | /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] ... | 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(%r... | /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,"s... | 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
... | /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);
... | 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 (%r... | /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 han... | 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)... | /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 */
... | 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 ... | /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, ... | 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,... | /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 hand... | 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 0x6... | /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... | 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 ... | /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]*/;
I... | 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... | /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... | 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(%r... | /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[M... | 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 $0x36... | /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_cap... | 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 0x8d9... | /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);
... | 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... | /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);
... | 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 0x8dc... | /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,... | 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 $0... | /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
c... | /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... | /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_g... | 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, -0... | /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);
... | 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... | /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... | /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 %... | /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_p... | 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 0x... | /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); */... | 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... | /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_... | 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 allocat... | 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), %r... | /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("Memo... | 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), %r... | /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 ... | 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, ... | /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... | 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(%rs... | /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... | 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, %... | /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_... | 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 %r1... | /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;
I... | 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, %... | /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[... | 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, 0... | /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
inc... | /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 = ... | 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... | /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... | 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... | /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
pop... | /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]=in... | 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
c... | /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; \... | 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 %... | /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... | 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
... | /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=lastGAhand... | 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 # 0xd... | /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... | 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 0... | /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 ImGuiS... | 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
xo... | /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
... | /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;
i... | 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 ... | /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_star... | 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
unpcklp... | /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] != '#'))
tex... | 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);
... | 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 0x1c27f... | /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
... | 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 0x1c2... | /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... | 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
j... | /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), GetColorU... | 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 #... | /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.... | 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... | /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... | 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 0x1c... | /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 ... | 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
ad... | /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);
ImGui... | 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 0x1... | /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;
... | 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)
mo... | /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 tr... | 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), %x... | /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/0... | 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 0x1cf1... | /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])
i... | 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... | /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/0... | 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 # 0x55bd... | /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|ImGuiWindowFl... | 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, %... | /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;
... | 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, %x... | /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(ImG... | 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 $0x... | /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), %ea... | /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)
... | 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... | /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.FocusRequestNex... | 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), %r... | /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.NavI... | 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(%r1... | /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... | 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), %... | /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 p... | 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), %... | /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... | 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
mov... | /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... | 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, %xmm... | /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))
{
... | 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... | /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 !... | 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 %r... | /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 ... | 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... | /hbina[P]fatuous/thirdparty/imgui/imgui.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.