name string | code string | asm string | file string |
|---|---|---|---|
GA_Set_block_cyclic_proc_grid64 | void GA_Set_block_cyclic_proc_grid64(int g_a, int64_t block[], int64_t proc_grid[])
{
Integer aa, ndim;
Integer _ga_dims[MAXDIM];
Integer _ga_lo[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(block,_ga_dims, ndim);
COPYC2F(proc_grid,_ga_lo, ndim);
wnga_set_block_cycli... | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %r15
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60687
testq %rax, %rax
jle 0x8e793
movq %rax, %rcx
movq (%r15), %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x8, %r15
decq %rcx
jne 0x8e782
testq %rax, %rax
jle 0x8e7a9
movq (%r14), %rcx
movq %rcx, -0... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_tiled_proc_grid | void NGA_Set_tiled_proc_grid(int g_a, int block[], int 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, _b... | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %r15
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60687
testq %rax, %rax
jle 0x8e8ce
movq %rax, %rcx
movslq (%r15), %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x4, %r15
decq %rcx
jne 0x8e8bd
testq %rax, %rax
jle 0x8e8e4
movslq (%r14), %rcx
movq %rcx... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Set_tiled_irreg_proc_grid | void GA_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 0x60687
movq %rax, %r12
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x8d665
movq %rax, %r15
testq %r12, %r12
jle 0x8ea25
movq %r12, %rax
movslq (%r13... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_ghosts | void NGA_Set_ghosts(int g_a, int width[])
{
Integer aa, *ptr, ndim;
Integer _ga_work[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
if(!width)ptr=(Integer*)0;
else {
COPYC2F(width,_ga_work, ndim);
ptr = _ga_work;
}
wnga_set_ghosts(aa, ptr);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60687
testq %r14, %r14
je 0x8ed0f
movq %rsp, %rsi
testq %rax, %rax
jle 0x8ed11
decq %rax
movslq (%r14), %rcx
movq %rcx, (%rsp,%rax,8)
addq $0x4, %r14
addq $-0x1, %rax
jb 0x8ecfc
jmp 0x8ed11
xorl %esi, %esi
movq %rbx, %rdi
c... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Set_irreg_distr64 | void GA_Set_irreg_distr64(int g_a, int64_t map[], int64_t block[])
{
Integer aa, ndim;
Integer _ga_work[MAXDIM];
Integer *_ga_map_capi;
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(block,_ga_work, ndim);
_ga_map_capi = copy_map64(block, (int)ndim, map);
wnga_set_irreg_dist... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60687
testq %rax, %rax
jle 0x8ee07
movq %r15, %rcx
movq %rax, %rdx
movq (%rcx), %rsi
movq %rsi, -0x8(%rsp,%rdx,8)
addq $0x8, %rcx
decq %rdx
jne 0x8edf6
movq %r15, %rdi
movl %eax, %esi
movq %r14, %... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_irreg_distr | void NGA_Set_irreg_distr(int g_a, int map[], int block[])
{
Integer aa, ndim;
Integer _ga_work[MAXDIM];
Integer *_ga_map_capi;
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(block,_ga_work, ndim);
_ga_map_capi = copy_map(block, (int)ndim, map);
wnga_set_irreg_distr(aa, _ga_m... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60687
testq %rax, %rax
jle 0x8ee6d
movq %r15, %rcx
movq %rax, %rdx
movslq (%rcx), %rsi
movq %rsi, -0x8(%rsp,%rdx,8)
addq $0x4, %rcx
decq %rdx
jne 0x8ee5c
movq %r15, %rdi
movl %eax, %esi
movq %r14,... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_irreg_distr64 | void NGA_Set_irreg_distr64(int g_a, int64_t map[], int64_t block[])
{
Integer aa, ndim;
Integer _ga_work[MAXDIM];
Integer *_ga_map_capi;
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(block,_ga_work, ndim);
_ga_map_capi = copy_map64(block, (int)ndim, map);
wnga_set_irreg_dis... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x60687
testq %rax, %rax
jle 0x8eed3
movq %r15, %rcx
movq %rax, %rdx
movq (%rcx), %rsi
movq %rsi, -0x8(%rsp,%rdx,8)
addq $0x8, %rcx
decq %rdx
jne 0x8eec2
movq %r15, %rdi
movl %eax, %esi
movq %r14, %... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Pgroup_create | int NGA_Pgroup_create(int *list, int count)
{
Integer acount = (Integer)count;
int i;
int grp_id;
Integer *_ga_map_capi;
_ga_map_capi = (Integer*)malloc(count * sizeof(Integer));
for (i=0; i<count; i++)
_ga_map_capi[i] = (Integer)list[i];
grp_id = (int)wnga_pgroup_create(_ga_map_capi,... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r15
movslq %esi, %rbx
leaq (,%rbx,8), %rdi
callq 0x33b0
movq %rax, %r14
testl %ebx, %ebx
jle 0x8f026
movl %ebp, %eax
xorl %ecx, %ecx
movslq (%r15,%rcx,4), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x8f016
movq %r14, %rd... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_List_nodeid | void NGA_List_nodeid(int *nlist, int nprocs)
{
Integer i, procs;
Integer *list;
procs = (Integer)(nprocs);
list = malloc(procs*sizeof(int));
wnga_list_nodeid(list, procs);
for (i=0; i<procs; i++) {
nlist[i] = (int)list[i];
}
free(list);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r14
leaq (,%r14,4), %rdi
callq 0x33b0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x68751
testl %r14d, %r14d
jle 0x8f1e8
xorl %eax, %eax
movl (%r15,%rax,8), %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
cmpq %rax, %r14
jne 0x8f1d9
movq %r15, %rdi
popq %... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Merge_distr_patch64 | void NGA_Merge_distr_patch64(int g_a, int64_t *alo, int64_t *ahi,
int g_b, int64_t *blo, int64_t *bhi)
{
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 _... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %r14
movq %r8, %r12
movl %ecx, %r15d
movq %rdx, %r13
movq %rsi, %rbx
movslq %edi, %rdi
movq %rdi, 0x8(%rsp)
callq 0x64ee9
movq %rax, %rbp
movslq %r15d, %r15
movq %r15, %rdi
callq 0x64ee9
testq %rbp, %r... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Get_ghost_block | void NGA_Get_ghost_block(int g_a, int lo[], int hi[], void *buf, int ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ndim);
COPYC2F(ld,_ga_work, ndim-1);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movslq %edi, %r14
movq %r14, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x8f4bf
movq %rax, %rcx
movslq (%r13), %rdx
incq %rdx
movq %rdx, 0x78(%rsp,%rcx,8)
addq $0x4, %r13
decq %rcx
jne 0x8... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Strided_acc64 | void NGA_Strided_acc64(int g_a, int64_t lo[], int64_t hi[], int64_t skip[],
void* buf, int64_t ld[], void *alpha)
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_skip[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movslq %edi, %r14
movq %r14, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x8fef9
movq %rax, %rcx
movq (%rbp), %rdx
incq %rdx
movq %rdx, 0... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Strided_put | void NGA_Strided_put(int g_a, int lo[], int hi[], int skip[],
void* buf, int ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_skip[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movslq %edi, %r14
movq %r14, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x9017f
movq %rax, %rcx
movslq (%rbp), %rdx
incq %rdx
movq %rdx, 0xb8(%rsp,%rcx,8)
addq $0... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_NbAcc | void NGA_NbAcc(int g_a, int lo[], int hi[], void* buf,int ld[], void* alpha,
ga_nbhdl_t* nbhandle)
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ndim... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movslq %edi, %r15
movq %r15, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x90485
movq %rax, %rcx
movslq (%rbp), %rdx
incq %rdx
movq %rdx, 0x88(%rsp,%rcx,8)
addq $0... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Periodic_acc64 | void NGA_Periodic_acc64(int g_a, int64_t lo[], int64_t hi[], void* buf,int64_t ld[], void* alpha)
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo, ndim);
COPYINDEX_C2F(hi,_ga_hi, ndim);
COPYC2F(l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movslq %edi, %r15
movq %r15, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x909a0
movq %rax, %rcx
movq (%rbp), %rdx
incq %rdx
movq %rdx, 0x88(%rsp,%rcx,8)
addq $0x8... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Read_inc64 | long NGA_Read_inc64(int g_a, int64_t subscript[], long inc)
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer in=(Integer)inc;
Integer _ga_lo[MAXDIM];
COPYINDEX_C2F(subscript, _ga_lo, ndim);
return (long)wnga_read_inc(a, _ga_lo, in);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movslq %edi, %r14
movq %r14, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x90a90
movq (%r15), %rcx
incq %rcx
movq %rcx, -0x8(%rsp,%rax,8)
addq $0x8, %r15
decq %rax
jne 0x90a7c
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x75fb5
addq... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Unpack64 | void GA_Unpack64(int g_src, int g_dest, int g_mask, int64_t lo, int64_t hi, int64_t *icount)
{
Integer a = (Integer)g_src;
Integer b = (Integer)g_dest;
Integer s = (Integer)g_mask;
Integer icnt;
Integer alo = lo+1;
Integer ahi = hi+1;
wnga_unpack(a, b, s, alo, ahi, &icnt);
*icou... | pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movslq %edi, %rdi
movslq %esi, %rsi
movslq %edx, %rdx
incq %rcx
incq %r8
movq %rsp, %r14
movq %r14, %r9
callq 0x39792
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Access64 | void NGA_Access64(int g_a, int64_t lo[], int64_t hi[], void *ptr, int64_t ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM], _ga_hi[MAXDIM];
Integer _ga_work[MAXDIM];
COPYINDEX_C2F(lo,_ga_lo,ndim);
COPYINDEX_C2F(hi,_ga_hi,ndim);
wnga_access_ptr(a,_ga... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movslq %edi, %r12
movq %r12, %rdi
callq 0x64ee9
movq %rax, %r14
testq %rax, %rax
jle 0x90efa
movq %r14, %rax
movq (%rbp), %rcx
incq %rcx
movq %rcx, 0x38(%rsp,%rax,8)
addq $0x... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Access_ghosts64 | void NGA_Access_ghosts64(int g_a, int64_t dims[], void *ptr, int64_t ld[])
{
Integer a=(Integer)g_a;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM];
Integer _ga_work[MAXDIM];
wnga_access_ghost_ptr(a, _ga_lo, ptr, _ga_work);
COPYF2C_64(_ga_work,ld, ndim-1);
COPYF2C_64(_ga_lo, dim... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r12
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movslq %edi, %rbp
movq %rbp, %rdi
callq 0x64ee9
movq %rax, %r14
leaq 0x50(%rsp), %r15
leaq 0x10(%rsp), %r13
movq %rbp, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
callq 0... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Access_ghost_element64 | void NGA_Access_ghost_element64(int g_a, void *ptr, int64_t subscript[], int64_t 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... | 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 0x64ee9
testq %rax, %rax
jle 0x91358
movq %rax, %rcx
movq (%r12), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x8, %r12
decq %rcx
jne 0x91343
cmpq $0x2, %rax
jl 0x91... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Release64 | void NGA_Release64(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_release(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 0x64ee9
testq %rax, %rax
jle 0x9143d
movq %rax, %rcx
movq (%r15), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x8, %r15
decq %rcx
jne 0x91429
testq %rax, %rax
jle 0x91456
movq (%r14), %rcx
inc... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Locate64 | int NGA_Locate64(int g_a, int64_t subscript[])
{
logical st;
Integer a=(Integer)g_a, owner;
Integer ndim = wnga_ndim(a);
Integer _ga_lo[MAXDIM];
COPYINDEX_C2F(subscript,_ga_lo,ndim);
st = wnga_locate(a,_ga_lo,&owner);
if(st == TRUE) return (int)owner;
else return -1;
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x915dc
movq (%r14), %rcx
incq %rcx
movq %rcx, 0x8(%rsp,%rax,8)
addq $0x8, %r14
decq %rax
jne 0x915c8
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5da6b
movq %rax, %rcx
movl ... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Locate_num_blocks | int NGA_Locate_num_blocks(int g_a, int *lo, int *hi)
{
Integer ret;
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);
ret = wnga_locate_num_blocks(a, _ga_lo, _ga_hi);
return (int)ret;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r14
movq %rsi, %r15
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x91ab5
movq %rax, %rcx
movslq (%r15), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x4, %r15
decq %rcx
jne 0x91aa1
testq %rax, %rax
jle 0x91ace
movslq (%r14), %rcx... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Scatter64 | void NGA_Scatter64(int g_a, void *v, int64_t* subsArray[], int64_t n)
{
int64_t idx;
int 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(_s... | movq %rcx, %r8
movslq %edi, %rdi
movl $0x1, %ecx
jmp 0x74a2d
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Gather | void NGA_Gather(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_E... | movslq %edi, %rdi
movslq %ecx, %r8
movl $0x1, %ecx
jmp 0x74936
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Cgemm_c | void GA_Cgemm_c(char ta, char tb, int m, int n, int k,
SingleComplex alpha, int g_a, int g_b,
SingleComplex 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;
Int... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movslq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x68(%rsp), %rbp
leaq 0x18(%rsp), %rax
movlps %xmm0, (%rax)
leaq 0x20(%rsp), %r15
movlps %xmm1, (%r15)
leaq 0xf(%rsp), %r11
movb %dil, (%r11)
leaq 0xe(%rsp), %r10
movb %sil, (%r10)
mov... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Copy_patch64 | void NGA_Copy_patch64(char trans, int g_a, int64_t alo[], int64_t ahi[],
int g_b, int64_t blo[], int64_t bhi[])
{
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[MAXDI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %r9, %r15
movl %r8d, %r14d
movq %rcx, %r12
movq %rdx, %rbp
movb %dil, 0xf(%rsp)
movslq %esi, %rbx
movq %rbx, %rdi
callq 0x64ee9
movq %rax, %r13
movslq %r14d, %r14
movq %r14, %rdi
callq 0x64ee9
testq %r13, %... | /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 0x64ee9
movq %rax, %... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Matmul_patch64 | void NGA_Matmul_patch64(char transa, char transb, void* alpha, void *beta,
int g_a, int64_t alo[], int64_t ahi[],
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 = wn... | 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 0x64ee9
movq %rax, %... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Ddot_patch | double NGA_Ddot_patch(int g_a, char t_a, int alo[], int ahi[],
int g_b, char t_b, int blo[], int bhi[])
{
double 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];
Int... | 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 0x64ee9
movq %rax, %r12
movslq %ebp, %r14
movq %r14, %rdi
callq 0x64ee9
testq %r1... | /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 0x64ee9
movq %rax, %r12
movslq %ebp, %r14
movq %r14, %rdi
callq 0x64ee9
testq %r1... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Lldot_patch64 | long long NGA_Lldot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
int g_b, char t_b, int64_t blo[], int64_t bhi[])
{
long long res;
Integer a=(Integer)g_a;
Integer andim = wnga_ndim(a);
Integer b=(Integer)g_b;
Integer bndim = wnga_ndim(b);
Integer _ga_alo[MA... | 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 0x64ee9
movq %rax, %r12
movslq %ebp, %r14
movq %r14, %rdi
callq 0x64ee9
testq %r1... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Fdot_patch64 | float NGA_Fdot_patch64(int g_a, char t_a, int64_t alo[], int64_t ahi[],
int g_b, char t_b, int64_t blo[], int64_t bhi[])
{
float 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], _g... | 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, 0xb(%rsp)
movb %r9b, 0xa(%rsp)
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x64ee9
movq %rax, %r12
movslq %ebp, %r14
movq %r14, %rdi
callq 0x64ee9
testq %r1... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Fill_patch64 | void NGA_Fill_patch64(int g_a, int64_t lo[], int64_t hi[], void *val)
{
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_fill_patch(a, _ga_lo, _ga_hi, val);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movslq %edi, %r14
movq %r14, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x9470f
movq %rax, %rcx
movq (%r12), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x8, %r12
decq %rcx
jne 0x946fa
testq %rax, %rax
jle 0x... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Zero_patch64 | void NGA_Zero_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_zero_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 0x64ee9
testq %rax, %rax
jle 0x947ef
movq %rax, %rcx
movq (%r15), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x8, %r15
decq %rcx
jne 0x947db
testq %rax, %rax
jle 0x94808
movq (%r14), %rcx
inc... | /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 0x64ee9
movq %rax, %r15
movslq %ebp, %r13
movq %r13, %... | /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 0x64ee9
testq %rax, %rax
jle 0x954b1
movq %rax, %rcx
movq (%r13), %rdx
incq %rdx
movq %rdx, 0... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Abs_value_patch64 | void GA_Abs_value_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_abs_value_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 0x64ee9
testq %rax, %rax
jle 0x95641
movq %rax, %rcx
movq (%r15), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x8, %r15
decq %rcx
jne 0x9562d
testq %rax, %rax
jle 0x9565a
movq (%r14), %rcx
inc... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Add_constant_patch | void GA_Add_constant_patch(int g_a, int *lo, int* hi, void *alpha)
{
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_add_constant_patch(a, _ga_lo, _ga_hi, alpha);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movslq %edi, %r14
movq %r14, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x956b3
movq %rax, %rcx
movslq (%r12), %rdx
incq %rdx
movq %rdx, 0x38(%rsp,%rcx,8)
addq $0x4, %r12
decq %rcx
jne 0x9569e
testq %rax, %rax
jle ... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Elem_multiply_patch64 | void GA_Elem_multiply_patch64(int g_a, int64_t alo[], int64_t ahi[],
int g_b, int64_t blo[], int64_t bhi[],
int g_c, int64_t clo[], int64_t chi[])
{
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer c = (Integer)g_c;
Integer andim = w... | 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 0x64ee9
movq %rax, %r14
movq %r13, 0x18... | /GlobalArrays[P]ga/global/src/capi.c |
GA_Elem_maximum_patch | void GA_Elem_maximum_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 0x64ee9
movq %rax, %r14
movq %r13, 0x18... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Nbget_field | void NGA_Nbget_field(int g_a, int *lo, int *hi, int foff, int fsize,
void *buf, int *ld, ga_nbhdl_t *nbhandle) {
Integer a = (Integer)g_a;
Integer andim = wnga_ndim(a);
Integer _alo[MAXDIM], _ahi[MAXDIM];
Integer _ld[MAXDIM];
COPYINDEX_C2F(lo,_alo, andim);
COPYINDEX_C2F(hi,_ahi, andim);
COPYINDEX_C... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r13
movslq %edi, %r14
movq %r14, %rdi
callq 0x64ee9
testq %rax, %rax
jle 0x969bb
movq %rax, %rcx
movslq (%r13), %rdx
incq %rdx
movq %rdx, 0x78(%rsp,%rcx,8)
addq ... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Sprs_array_column_distribution64 | void NGA_Sprs_array_column_distribution64(int s_a, int iproc, int64_t *lo, int64_t *hi)
{
Integer sa = (Integer)s_a;
Integer ip = (Integer)iproc;
Integer ilo, ihi;
wnga_sprs_array_column_distribution(sa,ip,&ilo,&ihi);
*lo = (int64_t)ilo;
*hi = (int64_t)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 0x3c20c
movq (%r15), %rax
movq %rax, (%r14)
movq (%r12), %rax
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
pop... | /GlobalArrays[P]ga/global/src/capi.c |
NGA_Sprs_array_get_block64 | int NGA_Sprs_array_get_block64(int s_a, int64_t irow, int64_t icol,
int64_t **idx, int64_t **jdx, void **data, int64_t *ilo,
int64_t *ihi, int64_t *jlo, int64_t *jhi)
{
Integer sa = (Integer)s_a;
Integer ir = (Integer)irow;
Integer ic = (Integer)icol;
Integer il, ih, jl, jh;
void *id, *jd;
int ret =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movslq %edi, %rdi
leaq 0x10(%rsp), %rax
leaq 0x20(%rsp), %rbp
leaq 0x28(%rsp), %r15
leaq 0x30(%rsp), %r13
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r8
movq %r12, %rcx
pushq %rax
pushq %rbp
pushq %r15
pushq %r1... | /GlobalArrays[P]ga/global/src/capi.c |
ddb_ap | void ddb_ap(long ndims, double * qedims, Integer * ardims, Integer * pedims,
long npes, long npdivs, long * pdivs)
{
long bq;
long i, k, g;
long idim;
for(idim=0;idim<ndims-1;idim++){
g = dd_lk(pdivs,npdivs,qedims[idim]);
bq = pdivs[g] ;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r10
movq %rdi, %r15
cmpq $0x2, %rdi
jl 0x9851c
movq %r9, %rbx
movq %rdx, %r12
movq %rsi, %r13
leaq -0x1(%r15), %rax
movq %rax, 0x18(%rsp)
leaq -0x2(%r15), %rax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
movq ... | /GlobalArrays[P]ga/global/src/decomp.c |
ga_sort_scat | void ga_sort_scat(pn, v, i, j, base, type)
Integer *pn;
void *v;
Integer *i;
Integer *j;
Integer *base;
Integer type;
{
switch (type){
case C_DBL: ga_sort_scat_dbl_(pn, (double*)v, i,j,base);break;
case C_DCPL: ga_sort_scat_dcpl_(pn, (DoubleComplex*)v, i,j,base); break;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq -0x3e9(%r9), %rax
cmpq $0x6, %rax
ja 0x98f92
leaq 0x2279c(%rip), %r10 # 0xbb154
movslq (%r10,%rax,4), %rax
addq %r10, %rax
jmpq *%rax
movq (%rdi), %r10
cmpq $0x2, %r10
jl 0x994e0
movq %r10, %rdi
shrq %rdi
leaq -0x8(,%r10,8), %rax
cmpq $0x1, %rdi... | /GlobalArrays[P]ga/global/src/hsort.scat.c |
genRandLong | unsigned long genRandLong(MTRand* rand) {
unsigned long y;
static unsigned long mag[2] = {0x0, 0x9908b0df}; /* mag[x] = x * 0x9908b0df for x = 0,1 */
if(rand->index >= STATE_VECTOR_LENGTH || rand->index < 0) {
/* generate STATE_VECTOR_LENGTH words at a time */
int kk;
if(rand->index >= STATE_VECTOR_L... | cmpl $0x270, 0x1380(%rdi) # imm = 0x270
jb 0x99c8a
je 0x99bb8
movq $0x1105, (%rdi) # imm = 0x1105
movl $0x1, %eax
movl $0x1105, %ecx # imm = 0x1105
imull $0x17b5, %ecx, %ecx # imm = 0x17B5
movq %rcx, (%rdi,%rax,8)
incq %rax
cmpq $0x270, %rax # imm = 0x270
jne 0x99b99
movl $0x270, 0x1... | /GlobalArrays[P]ga/global/src/mtwister.c |
armci_stride_info_init | void armci_stride_info_init(stride_info_t *sinfo,
void *base_ptr,
int stride_levels,
const int *stride_arr,
const int *seg_count) {
int i;
assert(sinfo!=NULL);
assert(stride_levels>=0);
assert(stride_levels<=ARMCI_MAX_STRIDE_LEVEL);
for(i=0; i<stride_levels; i++) {
if(i==0)
... | pushq %rax
testq %rdi, %rdi
je 0xa4903
testl %edx, %edx
js 0xa4922
cmpl $0x8, %edx
jg 0xa4941
movl %edx, %eax
testl %edx, %edx
je 0xa4836
xorl %r9d, %r9d
testq %r9, %r9
je 0xa4822
movl (%r8,%r9,4), %r10d
imull -0x4(%rcx,%r9,4), %r10d
cmpl %r10d, (%rcx,%r9,4)
jge 0xa482e
jmp 0xa48c5
movl (%rcx), %r10d
cmpl (%r8), %r10d
... | /GlobalArrays[P]ga/comex/src-armci/iterator.c |
flatcc_verify_string_vector_field | int flatcc_verify_string_vector_field(flatcc_table_verifier_descriptor_t *td,
voffset_t id, int required)
{
uoffset_t base;
check_field(td, id, required, base);
return verify_string_vector(td->buf, td->end, base, read_uoffset(td->buf, base));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movq %r14, %rcx
callq 0x7e60
testl %eax, %eax
sete %dl
movl (%r14), %ecx
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x8125
movl %ecx, %r9d
movq (%rbx), %rcx
movl (%rcx,%r9), %r10d
leal (%r10,%r9), %edi
movl $... | /dvidelabs[P]flatcc/src/runtime/verifier.c |
flatcc_verify_table_field | int flatcc_verify_table_field(flatcc_table_verifier_descriptor_t *td,
voffset_t id, int required, flatcc_table_verifier_f tvf)
{
uoffset_t base;
check_field(td, id, required, base);
return verify_table(td->buf, td->end, base, read_uoffset(td->buf, base), td->ttl, tvf);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rcx
callq 0x7e60
testl %eax, %eax
sete %dl
movl (%r15), %ecx
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x81f5
movl %ecx, %eax
movq (%r14), %rcx
movl 0x8(%r14), %edx
movl (%rcx,%rax), %... | /dvidelabs[P]flatcc/src/runtime/verifier.c |
flatcc_verify_table_vector_field | int flatcc_verify_table_vector_field(flatcc_table_verifier_descriptor_t *td,
voffset_t id, int required, flatcc_table_verifier_f tvf)
{
uoffset_t base;
check_field(td, id, required, base);
return verify_table_vector(td->buf, td->end, base, read_uoffset(td->buf, base), td->ttl, tvf);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x34(%rsp), %r15
movq %r15, %rcx
callq 0x7e60
movl %eax, %ebp
testl %eax, %eax
sete %cl
movl (%r15), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x8486
movl 0xc(%r14), %r15d
testl... | /dvidelabs[P]flatcc/src/runtime/verifier.c |
attoAppInit | void attoAppInit(struct AAppProctable *proctable) {
int i;
aAppDebugPrintf("%s[%u]: argc = %d, argv = %p", __func__, 0, a_app_state->argc, (void *)a_app_state->argv);
for (i = 0; i < a_app_state->argc; ++i) aAppDebugPrintf("\targv[%d] = '%s'", i, a_app_state->argv[i]);
aAppDebugPrintf("\tOpenGL version %s", opengl_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3cfa(%rip), %r12 # 0x5148
movq (%r12), %rax
movl (%rax), %ecx
movq 0x8(%rax), %r8
leaq 0x1bb1(%rip), %rdi # 0x3010
leaq 0x1bc7(%rip), %rsi # 0x302d
xorl %edx, %edx
xorl %eax, %eax
callq 0x1280
movq (%r12), %rax
cmpl $0x0, (%rax... | /w23[P]atto/examples/app.c |
main | int main(int argc, char *argv[]) {
ATimeUs timestamp = aAppTime();
XSetWindowAttributes winattrs;
Atom delete_message;
#ifndef ATTO_EGL
int nglxconfigs = 0;
GLXFBConfig *glxconfigs = NULL;
#endif
XVisualInfo *vinfo = NULL;
ATimeUs last_paint = 0;
ATTO_ASSERT(a__x11.display = XOpenDisplay(NULL));
#ifndef ATTO_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movl %edi, %ebp
callq 0x16e0
movl %eax, %ebx
xorl %edi, %edi
callq 0x10f0
movq %rax, 0x3e1f(%rip) # 0x55a8
testq %rax, %rax
je 0x2221
movl $0x30a2, %edi # imm = 0x30A2
callq 0x1200... | /w23[P]atto/src/app_x11.c |
WriteCounts(wabt::Stream&, std::map<wabt::OpcodeInfo, unsigned long, std::less<wabt::OpcodeInfo>, std::allocator<std::pair<wabt::OpcodeInfo const, unsigned long>>> const&) | void WriteCounts(Stream& stream, const OpcodeInfoCounts& info_counts) {
typedef std::pair<Opcode, size_t> OpcodeCountPair;
std::map<Opcode, size_t> counts;
for (auto& info_count_pair: info_counts) {
Opcode opcode = info_count_pair.first.opcode();
size_t count = info_count_pair.second;
counts[opcode] ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x60(%rsp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %rax, 0x20(%r14)
movq 0x18(%rsi), %r12
addq $0x8, %r15
cmpq %r15, %r12
je ... | /asbish[P]wabt/src/tools/wasm-opcodecnt.cc |
wabt::(anonymous namespace)::BinaryReader::ReadSections() | Result BinaryReader::ReadSections() {
Result result = Result::Ok;
Index section_index = 0;
bool seen_section_code[static_cast<int>(BinarySection::Last) + 1] = {false};
for (; state_.offset < state_.size; ++section_index) {
uint32_t section_code;
Offset section_size;
CHECK_RESULT(ReadU32Leb128(§... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
xorl %eax, %eax
movq %rax, 0x106(%rsp)
movq %rax, 0x100(%rsp)
movq 0x18(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
jae 0x2c7cd
movq %rdi, %rbx
leaq 0x48(%rdi), %rax
movq %rax, (%rsp)
leaq 0xd8(%rdi), %rax
movq %rax, 0xe8... | /asbish[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadMemory(wabt::Limits*) | Result BinaryReader::ReadMemory(Limits* out_page_limits) {
uint32_t flags;
uint32_t initial;
uint32_t max = 0;
CHECK_RESULT(ReadU32Leb128(&flags, "memory flags"));
CHECK_RESULT(ReadU32Leb128(&initial, "memory initial page count"));
bool has_max = flags & WABT_BINARY_LIMITS_HAS_MAX_FLAG;
bool is_shared = f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, 0x4(%rsp)
leaq 0xf217(%rip), %rdx # 0x3be58
leaq 0xc(%rsp), %rsi
callq 0x2c83e
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x2ccb5
leaq 0xf209(%rip), %rdx # 0x3be65
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
ca... | /asbish[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadEventType(unsigned int*) | Result BinaryReader::ReadEventType(Index* out_sig_index) {
uint32_t attribute;
CHECK_RESULT(ReadU32Leb128(&attribute, "event attribute"));
ERROR_UNLESS(attribute == 0, "event attribute must be 0");
CHECK_RESULT(ReadIndex(out_sig_index, "event signature index"));
return Result::Ok;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf15e(%rip), %rdx # 0x3beed
leaq 0x8(%rsp), %rsi
callq 0x2c83e
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x2cde5
cmpl $0x0, 0x8(%rsp)
je 0x2cdbd
leaq 0xf14c(%rip), %rsi # 0x3befd
movq %r14, %rdi
xorl %eax, %eax
callq 0x28efa
jmp ... | /asbish[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadV128(v128*, char const*) | Result BinaryReader::ReadV128(v128* out_value, const char* desc) {
return ReadT(out_value, "v128", desc);
} | movq %rdx, %rcx
movq 0x18(%rdi), %rax
leaq 0x10(%rax), %rdx
cmpq (%rdi), %rdx
jbe 0x2d446
pushq %rax
leaq 0xdc75(%rip), %rsi # 0x3b0a3
leaq 0xd004(%rip), %rdx # 0x3a439
xorl %eax, %eax
callq 0x28efa
movl $0x1, %eax
addq $0x8, %rsp
retq
movq 0x8(%rdi), %rcx
movups (%rcx,%rax), %xmm0
movups %xmm0, (%rsi)
addq $... | /asbish[P]wabt/src/binary-reader.cc |
wabt::BinaryReaderLogging::WriteIndent() | void BinaryReaderLogging::WriteIndent() {
static char s_indent[] =
" "
" ";
static const size_t s_indent_len = sizeof(s_indent) - 1;
size_t i = indent_;
while (... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x20(%rdi), %r15
cmpq $0x8f, %r15
jb 0x2f616
leaq 0x1ec20(%rip), %r14 # 0x4e210
movq 0x10(%rbx), %rdi
movl $0x8e, %edx
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x384d6
addq $-0x8e, %r15
cmpq $0x8e, %r15
ja 0x2f5f0
testq %r15, %r15
je 0x2f639
movq ... | /asbish[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnImportTable(unsigned int, wabt::string_view, wabt::string_view, unsigned int, wabt::Type, wabt::Limits const*) | Result BinaryReaderLogging::OnImportTable(Index import_index,
string_view module_name,
string_view field_name,
Index table_index,
Type elem_type,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movl %esi, %ebx
movq %rdi, %rbp
movq 0xd0(%rsp), %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2fbd9
movq %rbp, %rdi
callq 0x2f5d4
movq 0x10(%rbp), %r15
... | /asbish[P]wabt/src/binary-reader-logging.cc |
wabt::InitStdio() | void InitStdio() {
#if COMPILER_IS_MSVC
int result = _setmode(_fileno(stdout), _O_BINARY);
if (result == -1) {
perror("Cannot set mode binary to stdout");
}
result = _setmode(_fileno(stderr), _O_BINARY);
if (result == -1) {
perror("Cannot set mode binary to stderr");
}
#endif
} | retq
nop
| /asbish[P]wabt/src/common.cc |
wabt::WriteFixedU32Leb128(wabt::Stream*, unsigned int, char const*) | void WriteFixedU32Leb128(Stream* stream, uint32_t value, const char* desc) {
uint8_t data[MAX_U32_LEB128_BYTES];
Offset length =
WriteFixedU32Leb128Raw(data, data + MAX_U32_LEB128_BYTES, value);
stream->WriteData(data, length, desc);
} | pushq %rax
movq %rdx, %rcx
movl %esi, %edx
orb $-0x80, %dl
leaq 0x3(%rsp), %rax
movb %dl, (%rax)
movl %esi, %edx
shrl $0x7, %edx
orb $-0x80, %dl
movb %dl, 0x1(%rax)
movl %esi, %edx
shrl $0xe, %edx
orb $-0x80, %dl
movb %dl, 0x2(%rax)
movl %esi, %edx
shrl $0x15, %edx
orb $-0x80, %dl
movb %dl, 0x3(%rax)
shrl $0x1c, %esi
m... | /asbish[P]wabt/src/leb128.cc |
wabt::WriteFloatHex(char*, unsigned long, unsigned int) | void WriteFloatHex(char* buffer, size_t size, uint32_t bits) {
return FloatWriter<float>::WriteHex(buffer, size, bits);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %edx, %eax
shrl $0x17, %eax
movzbl %al, %ecx
leal -0x7f(%rcx), %eax
testl %edx, %edx
js 0x3574f
movq %rsp, %rdi
jmp 0x35758
leaq 0x1(%rsp), %rdi
movb $0x2d, -0x1(%rdi)
andl $0x7fffff, %edx # imm = 0x7FFFFF
cmpl $0x80, %eax
jne 0x357ce
leaq 0x3(%rdi), %... | /asbish[P]wabt/src/literal.cc |
wabt::Result wabt::ParseInt<unsigned char>(char const*, char const*, unsigned char*, wabt::ParseIntType) | Result ParseInt(const char* s,
const char* end,
U* out,
ParseIntType parse_type) {
typedef typename std::make_signed<U>::type S;
uint64_t value;
bool has_sign = false;
if (*s == '-' || *s == '+') {
if (parse_type == ParseIntType::UnsignedOnly) {
return R... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x35ea8
cmpl $0x2b, %eax
jne 0x35eb7
testl %ecx, %ecx
je 0x35eed
cmpb $0x2d, %al
sete %bpl
incq %rdi
jmp 0x35eb9
xorl %ebp, %ebp
movq %rsp, %rdx
callq 0x34680
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x35f04
movq (%rsp), ... | /asbish[P]wabt/src/literal.cc |
wabt::Opcode::IsEnabled(wabt::Features const&) const | bool Opcode::IsEnabled(const Features& features) const {
switch (enum_) {
case Opcode::Try:
case Opcode::Catch:
case Opcode::Throw:
case Opcode::Rethrow:
case Opcode::BrOnExn:
return features.exceptions_enabled();
case Opcode::ReturnCallIndirect:
case Opcode::ReturnCall:
retur... | movl (%rdi), %eax
addl $-0x6, %eax
cmpl $0x1bf, %eax # imm = 0x1BF
ja 0x361cc
leaq 0xa263(%rip), %rcx # 0x40404
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb 0x4(%rsi), %al
retq
movb 0x5(%rsi), %al
retq
movb 0x2(%rsi), %al
retq
movb 0x8(%rsi), %al
retq
movb 0x9(%rsi), %al
retq
xorl %eax, %e... | /asbish[P]wabt/src/opcode.cc |
wabt::Opcode::GetSimdLaneCount() const | uint32_t Opcode::GetSimdLaneCount() const {
switch (enum_) {
case Opcode::I8X16ExtractLaneS:
case Opcode::I8X16ExtractLaneU:
case Opcode::I8X16ReplaceLane:
return 16;
break;
case Opcode::I16X8ExtractLaneS:
case Opcode::I16X8ExtractLaneU:
case Opcode::I16X8ReplaceLane:
return ... | movl $0xffffff26, %eax # imm = 0xFFFFFF26
addl (%rdi), %eax
cmpl $0x13, %eax
jae 0x361f3
movl $0x6db77, %ecx # imm = 0x6DB77
btl %eax, %ecx
jae 0x361f3
movl %eax, %eax
leaq 0xa915(%rip), %rcx # 0x40b04
movl (%rcx,%rax,4), %eax
retq
pushq %rax
callq 0x24100
nop
| /asbish[P]wabt/src/opcode.cc |
wabt::Opcode::GetBytes() const | std::vector<uint8_t> Opcode::GetBytes() const {
std::vector<uint8_t> result;
if (HasPrefix()) {
result.push_back(GetPrefix());
uint8_t buffer[5];
Offset length =
WriteU32Leb128Raw(buffer, buffer + sizeof(buffer), GetCode());
assert(length != 0);
result.insert(result.end(), buffer, buffer... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl (%rsi), %eax
leaq 0x18120(%rip), %r15 # 0x4e340
cmpq $0x1c5, %rax # imm = 0x1C5
ja 0x36237
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
movb 0x24(%rcx,%r15), %c... | /asbish[P]wabt/src/opcode.cc |
wabt::OptionParser::OptionParser(char const*, char const*) | OptionParser::OptionParser(const char* program_name, const char* description)
: program_name_(program_name),
description_(description),
on_error_([this](const std::string& message) { DefaultError(message); }) {
// Add common options
AddOption("help", "Print this help message", [this]() {
PrintH... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdx
callq 0x240b0
leaq 0x20(%rbx), %rdi
movq %rsp, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x240b0
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movup... | /asbish[P]wabt/src/option-parser.cc |
wabt::OptionParser::Parse(int, char**) | void OptionParser::Parse(int argc, char* argv[]) {
size_t arg_index = 0;
for (int i = 1; i < argc; ++i) {
const char* arg = argv[i];
if (arg[0] == '-') {
if (arg[1] == '-') {
// Long option.
int best_index = -1;
int best_length = 0;
int best_count = 0;
for (siz... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, %r13
movq $0x0, 0x28(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x2, %esi
jl 0x37359
movl $0x1, %r15d
movq %r13, 0x8(%rsp)
movslq %r15d, %rax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rdx
cmpb $0x2d, (%rdx)
jne 0x... | /asbish[P]wabt/src/option-parser.cc |
wabt::OptionParser::PrintHelp() | void OptionParser::PrintHelp() {
printf("usage: %s [options]", program_name_.c_str());
for (size_t i = 0; i < arguments_.size(); ++i) {
Argument& argument = arguments_[i];
switch (argument.count) {
case ArgumentCount::One:
printf(" %s", argument.name.c_str());
break;
case Argum... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0xb153(%rip), %rdi # 0x42557
xorl %eax, %eax
callq 0x24050
movq 0x58(%rbx), %rax
cmpq %rax, 0x60(%rbx)
je 0x37473
movl $0x20, %r14d
leaq 0x4341(%rip), %r15 # 0x3b763
movabsq $-0x3333333333... | /asbish[P]wabt/src/option-parser.cc |
wabt::Stream::WriteMemoryDump(void const*, unsigned long, unsigned long, wabt::PrintChars, char const*, char const*) | void Stream::WriteMemoryDump(const void* start,
size_t size,
size_t offset,
PrintChars print_chars,
const char* prefix,
const char* desc) {
const uint8_t* p = static_cast<co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, 0x14(%rsp)
movq %rcx, 0x18(%rsp)
testq %rdx, %rdx
jle 0x384c6
movq %r9, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
addq %rsi, %r15
subq %rsi, 0x18(%rsp)
movb $0x20, %bl
movq %r9, 0x20(%rsp)
testq %r14, %r14
je 0x3836... | /asbish[P]wabt/src/stream.cc |
wabt::FileStream::CreateStdout() | std::unique_ptr<FileStream> FileStream::CreateStdout() {
return std::unique_ptr<FileStream>(new FileStream(stdout));
} | pushq %rbx
movq %rdi, %rbx
movl $0x38, %edi
callq 0x241e0
movq 0x15439(%rip), %rcx # 0x4dfb8
movq (%rcx), %rcx
xorl %edx, %edx
movq %rdx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq %rdx, 0x18(%rax)
leaq 0x1519e(%rip), %rsi # 0x4dd38
movq %rsi, (%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movb $0x0, 0x30(%rax)
m... | /asbish[P]wabt/src/stream.cc |
wabt::string_view::copy(char*, unsigned long, unsigned long) const | string_view::size_type string_view::copy(char* s,
size_type n,
size_type pos) const {
assert(pos <= size_);
size_t count = std::min(n, size_ - pos);
traits_type::copy(s, data_ + pos, count);
return count;
} | pushq %rbx
movq 0x8(%rdi), %rax
subq %rcx, %rax
jb 0x38df1
movq %rdx, %rbx
cmpq %rdx, %rax
cmovbq %rax, %rbx
testq %rbx, %rbx
je 0x38dec
addq (%rdi), %rcx
movq %rsi, %rdi
movq %rcx, %rsi
movq %rbx, %rdx
callq 0x24170
movq %rbx, %rax
popq %rbx
retq
leaq 0x9b28(%rip), %rdi # 0x42920
leaq 0x9a67(%rip), %rsi # 0x... | /asbish[P]wabt/src/string-view.cc |
wabt::string_view::compare(wabt::string_view) const | int string_view::compare(string_view s) const noexcept {
size_type rlen = std::min(size_, s.size_);
int result = traits_type::compare(data_, s.data_, rlen);
if (result != 0 || size_ == s.size_) {
return result;
}
return size_ < s.size_ ? -1 : 1;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq 0x8(%rdi), %r14
cmpq %rdx, %r14
cmovbq %r14, %rdx
xorl %ebp, %ebp
movl $0x0, %eax
testq %rdx, %rdx
je 0x38e6e
movq (%rdi), %rdi
callq 0x240d0
cmpq %rbx, %r14
sbbl %ebp, %ebp
orl $0x1, %ebp
testl %eax, %eax
cmovnel %eax, %ebp
cmpq %rbx, %r14
cmovel %eax, %ebp
movl %e... | /asbish[P]wabt/src/string-view.cc |
wabt::string_view::compare(unsigned long, unsigned long, char const*) const | string_view string_view::substr(size_type pos, size_type n) const {
assert(pos <= size_);
size_t count = std::min(n, size_ - pos);
return string_view(data_ + pos, count);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
subq %rsi, %rax
jb 0x3902b
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
cmpq %rdx, %rax
cmovbq %rax, %rbx
movq %rcx, %rdi
callq 0x240c0
movq %rax, %r15
cmpq %rax, %rbx
movq %rax, %rdx
cmovbq %rbx, %rdx
x... | /asbish[P]wabt/src/string-view.cc |
wabt::string_view::find(wabt::string_view, unsigned long) const | string_view::size_type string_view::find(string_view s, size_type pos) const
noexcept {
pos = std::min(pos, size_);
const_iterator iter = std::search(begin() + pos, end(), s.begin(), s.end());
return iter == end() ? npos : iter - begin();
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r8
cmpq %rcx, %r8
cmovbq %r8, %rcx
movq (%rdi), %rsi
leaq (%rcx,%rsi), %rdi
addq %r8, %rsi
leaq (%rdx,%rax), %rcx
movq %rax, %rdx
callq 0x39482
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
addq %rcx, %rdx
movq %rax, %rsi
subq %rcx, %rsi
cmpq %rdx, %rax
movq $-0x1, %... | /asbish[P]wabt/src/string-view.cc |
wabt::string_view::find(char, unsigned long) const | string_view::size_type string_view::find(char c, size_type pos) const noexcept {
return find(string_view(&c, 1), pos);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rcx
movb %sil, -0x1(%rcx)
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
cmpq %rdx, %rax
cmovbq %rax, %rdx
leaq (%rdx,%rsi), %rdi
addq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x39482
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
addq %rcx, %rdx
movq %rax, %rsi
subq %rcx, %rs... | /asbish[P]wabt/src/string-view.cc |
wabt::string_view::find(char const*, unsigned long, unsigned long) const | string_view::size_type string_view::find(const char* s,
size_type pos,
size_type n) const {
return find(string_view(s, n), pos);
} | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r8
cmpq %rdx, %r8
cmovbq %r8, %rdx
movq (%rdi), %rsi
leaq (%rdx,%rsi), %rdi
addq %r8, %rsi
addq %rax, %rcx
movq %rax, %rdx
callq 0x39482
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
addq %rcx, %rdx
movq %rax, %rsi
subq %rcx, %rsi
cmpq %rdx, %rax
movq $-0x1, %rax
cmo... | /asbish[P]wabt/src/string-view.cc |
Debug::print(char const*) | int Debug::print(const char* str)
{
#ifdef _MSC_VER
OutputDebugString(str);
return (int)strlen(str);
#else
return fputs(str, stderr);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0xe671(%rip), %rax # 0x10fd8
movq (%rax), %rsi
callq 0x22b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /craflin[P]libnstd/src/Debug.cpp |
Process::open(String const&, List<String> const&, unsigned int, Map<String, String> const&) | bool Process::open(const String& executable, const List<String>& args, uint streams, const Map<String, String>& environment)
{
Array<const char*> argv(args.size());
for (List<String>::Iterator i = args.begin(), end = args.end(); i != end; ++i)
argv.append((const char*)*i);
return open(executable, (int)args.si... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6490
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x6800
mov... | /craflin[P]libnstd/src/Process.cpp |
Process::write(void const*, unsigned long) | ssize Process::write(const void* buffer, usize len)
{
#ifdef _WIN32
DWORD i;
#ifdef _AMD64
const byte* bufferStart = (const byte*)buffer;
while(len > (usize)INT_MAX)
{
if(!WriteFile(hStdInWrite, buffer, INT_MAX, &i, NULL))
return -1;
buffer = (const byte*)buffer + i;
if(i != INT_MAX)
ret... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x20f0
addq $0x20, %rsp
popq %rbp
retq
nop
| /craflin[P]libnstd/src/Process.cpp |
Process::getExecutablePath() | String Process::getExecutablePath()
{
#ifdef _WIN32
char path[MAX_PATH + 1];
DWORD len = GetModuleFileName(NULL, path, sizeof(path) / sizeof(*path));
if (len != sizeof(path) / sizeof(*path))
return String::fromCString(path, len);
Buffer buffer;
buffer.resize((MAX_PATH << 1) * sizeof(char));
for (;;)
{... | pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp # imm = 0x1060
movq %rdi, -0x1060(%rbp)
movq %rdi, %rax
movq %rax, -0x1058(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x1050(%rbp)
callq 0x23d0
movq -0x1050(%rbp), %rdi
movl %eax, %edx
leaq 0x60fd(%rip), %rsi # 0xc2ad
movb $0x0, %al
callq ... | /craflin[P]libnstd/src/Process.cpp |
String::String(unsigned long) | explicit String(usize capacity)
{
data = (Data*)new char[(capacity + 1) * sizeof(char) + sizeof(Data)];
data->str = (char*)((byte*)data + sizeof(Data));
*((char*)data->str) = '\0';
data->len = 0;
data->ref = 1;
data->capacity = capacity;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
addq $0x20, %rdi
callq 0x2040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdx
addq $0x20, %rdx
movq (%ra... | /craflin[P]libnstd/src/../include/nstd/String.hpp |
List<String>::clear() | void clear()
{
for(Item* i = _begin.item, * end = &endItem; i != end; i = i->next)
{
i->~Item();
i->prev = freeItem;
freeItem = i;
}
_begin.item = &endItem;
endItem.prev = 0;
_size = 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xa1ed
movq -0x10(%rbp), %rdi
callq 0x7500
movq -0x20(%rbp), %rax
movq 0x50(... | /craflin[P]libnstd/src/../include/nstd/List.hpp |
HashSet<String>::insert(HashSet<String>::Iterator const&, String const&) | Iterator insert(const Iterator& position, const T& key)
{
Iterator it = find(key);
if (it != _end) return it;
if (!data)
{
data = (Item**)new char[sizeof(Item*) * capacity];
Memory::zero(data, sizeof(Item*)* capacity);
}
Item* item;
if (freeItem)
{
item = freeItem;
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x20(%rbp), %rsi
callq 0xa5d0
movq -0x68(%rbp), %rsi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xa680
testb $0x1, %al
jne 0xa3bc
jmp 0xa3c9
movq ... | /craflin[P]libnstd/src/../include/nstd/HashSet.hpp |
Time::Time(long, bool) | Time::Time(int64 time, bool utc) : utc(utc)
{
time_t now = (time_t)(time / 1000LL);
#ifdef _WIN32
tm* tm = utc ? ::gmtime(&now) : ::localtime(&now); // win32 gmtime and localtime are thread save
#else
struct tm tmBuf;
tm* tm = utc ? ::gmtime_r(&now, &tmBuf) : ::localtime_r(&now, &tmBuf);
#endif
sec = tm->tm_s... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x21(%rax)
movq -0x10(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq ... | /craflin[P]libnstd/src/Time.cpp |
main | int main(int argc, char* argv[])
{
srand(time(NULL));
// Command line arguments
double sine1 = 1;
double sine2 = 0;
double sine3 = 0;
double sine4 = 0;
double sine5 = 0;
double sine6 = 0;
double sine7 = 0;
double window_length = 20;
double som_frequency = 80000;
double ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %rbx
movl %edi, %ebp
xorl %edi, %edi
callq 0x15230
movl %eax, %edi
callq 0x15250
leaq 0xc809(%rip), %rsi # 0x22040
leaq 0x98(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x15e9e
cmpl $0xc, %ebp
jne 0x... | /haukri[P]MasterProject/Test/Phase_Coding_Lowpass_Example_Results.cpp |
void Eigen::internal::call_triangular_assignment_loop<10, false, Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 10u>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::swap_assign_op<double>>(Eigen::TriangularView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 10u>&, Eigen::Transp... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_triangular_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
Index dstRows = src.rows();
Index dstC... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq 0x10(%rax), %rsi
movq (%rdi), %rax
cmpq %rsi, 0x8(%rax)
jne 0x17b85
cmpq %rdx, 0x10(%rax)
je 0x17b94
movq %r14, %rdi
callq 0x17bc8
movq (%r14), ... | /haukri[P]MasterProject/Eigen/src/Core/TriangularMatrix.h |
Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::CwiseBinary... | void run(Kernel &kernel)
{
const Index size = kernel.size();
typedef typename Kernel::Scalar Scalar;
typedef typename Kernel::PacketType PacketType;
enum {
requestedAlignment = Kernel::AssignmentTraits::LinearRequiredAlignment,
packetSize = unpacket_traits<PacketType>::size,
dstIsAli... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x10(%rax), %rbx
imulq 0x8(%rax), %rbx
pushq $0x2
popq %rcx
movq %rbx, %rax
cqto
idivq %rcx
movq %rax, %r15
addq %rax, %r15
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x1d3e6
movq %r14, %rdi
movq %r12, %rsi
callq 0x1d400
addq $... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
iaf_psc_alpha::propagator_32(double, double, double, double) | double iaf_psc_alpha::propagator_32( double tau_syn, double tau, double C, double h )
{
const double P32_linear = 1 / ( 2. * C * tau * tau ) * h * h * ( tau_syn - tau ) * std::exp( -h / tau );
const double P32_singular = h / C * std::exp( -h / tau );
const double P32 =
-tau / ( C * ( 1 - tau / tau_syn ) ) * s... | subq $0x88, %rsp
movapd %xmm3, 0x30(%rsp)
movsd %xmm2, 0x8(%rsp)
movapd %xmm1, 0x60(%rsp)
movaps %xmm0, 0x40(%rsp)
xorpd 0x98a2(%rip), %xmm3 # 0x28600
movapd %xmm3, 0x20(%rsp)
movapd %xmm3, %xmm0
divsd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
callq 0x15400
movsd %xmm0, 0x58(%rsp)
movapd 0x30(%rsp), %xmm0
divsd 0x8(%rs... | /haukri[P]MasterProject/Network/Neuron/iaf_psc_alpha.cpp |
TemporalPhaseEncodingSynapse::update() | void TemporalPhaseEncodingSynapse::update() {
for(int i = 0; i < inputSize; i++) {
resetOutput();
for(int j = 0; j < spikeTimes.size(); j++) {
if(spikeTimes(j) <= clock->getCurrentTime() && spikeTimes(j) > -1) {
output[j] = new SpikeEvent();
output[j]->set... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
xorl %eax, %eax
pushq $0x18
popq %r15
pushq $0x28
popq %r12
cmpl 0x30(%rbx), %eax
jge 0x1fb7e
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
callq 0x1f930
xorl %r13d, %r13d
cmpq %r13, 0x28(%rbx)
jle 0x1fa8f
m... | /haukri[P]MasterProject/Network/Synapse/TemporalPhaseEncodingSynapse.cpp |
TemporalPhaseDecodingSynapse::TemporalPhaseDecodingSynapse(Population*, Population*) | TemporalPhaseDecodingSynapse::TemporalPhaseDecodingSynapse(Population* n_from, Population* n_to) :
param(new TemporalPhaseDecodingSynapse_param)
{
initialize(n_from, n_to);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x10d4f(%rip), %rax # 0x30d60
movq %rax, (%rdi)
pushq $0x20
popq %rdi
callq 0x15270
movl $0x28, (%rax)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movhps 0x85e1(%rip), %xmm1 # xmm1 = xmm1[0,1],mem[0,1]
movups %... | /haukri[P]MasterProject/Network/Synapse/TemporalPhaseDecodingSynapse.cpp |
FIR::getBuffer(int) | double FIR::getBuffer (int i){
if (i>= this->getTaps() or i<0) {
printf("\nThat value does not exist\n");
return 0.0;
}else{
return buff[i];
}
} | testl %esi, %esi
js 0x212ac
cmpl %esi, (%rdi)
jle 0x212ac
movl %esi, %eax
movq 0x40(%rdi), %rcx
cvtss2sd (%rcx,%rax,4), %xmm0
retq
pushq %rax
leaq 0x7bfd(%rip), %rdi # 0x28eb1
callq 0x15360
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
nop
| /haukri[P]MasterProject/Network/utils/FIR.cpp |
tcu::x11::X11Platform::X11Platform() | X11Platform::X11Platform (void)
: m_vkPlatform (m_eventState)
, m_eglPlatform (m_eventState)
{
#if defined (DEQP_SUPPORT_GLX)
m_glPlatform.registerFactory(glx::createContextFactory(m_eventState));
#endif // DEQP_SUPPORT_GLX
m_glPlatform.registerFactory(m_eglPlatform.createContextFactory());
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xd80760
movq -0x48(%rbp), %rdi
leaq 0xbeb38c(%rip), %rax # 0x10b8500
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x4d5280
jmp 0x4cd186
movq -0x48(%rbp), %rsi
movq %rsi, %rdi
addq $... | /kaydenl[P]VK-GL-CTS/framework/platform/X11/tcuX11Platform.cpp |
createPlatform() | tcu::Platform* createPlatform (void)
{
// From man:XinitThreads(3):
//
// The XInitThreads function initializes Xlib support for concurrent
// threads. This function must be the first Xlib function
// a multi-threaded program calls, and it must complete before any other
// Xlib call is made.
DE_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x4cd3a0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jne 0x4cd317
callq 0x4cb1d0
cmpl $0x0, %eax
setne %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
je 0x4cd348
x... | /kaydenl[P]VK-GL-CTS/framework/platform/X11/tcuX11Platform.cpp |
tcu::x11::VulkanPlatform::describePlatform(std::ostream&) const | void VulkanPlatform::describePlatform (std::ostream& dst) const
{
utsname sysInfo;
deMemset(&sysInfo, 0, sizeof(sysInfo));
if (uname(&sysInfo) != 0)
throw std::runtime_error("uname() failed");
dst << "OS: " << sysInfo.sysname << " " << sysInfo.release << " " << sysInfo.version << "\n";
dst << "CPU: " << sysIn... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x196(%rbp), %rdi
xorl %esi, %esi
movl $0x186, %edx # imm = 0x186
callq 0x4cdb80
leaq -0x196(%rbp), %rdi
callq 0x4cb0f0
cmpl $0x0, %eax
je 0x4cdab9
movl $0x10, %edi
callq 0x4cb7b0
movq %ra... | /kaydenl[P]VK-GL-CTS/framework/platform/X11/tcuX11VulkanPlatform.cpp |
tcu::x11::XcbWindow::XcbWindow(tcu::x11::XcbDisplay&, int, int, unsigned int*) | XcbWindow::XcbWindow (XcbDisplay& display, int width, int height, xcb_visualid_t* visual)
: WindowBase ()
, m_display (display)
{
xcb_connection_t* connection = m_display.getConnection();
uint32_t values[2];
m_window = xcb_generate_id(connection);
m_colormap = xcb_generate_id(connection);
if (visual == DE_NU... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4d5400
movq -0x68(%rbp), %rax
leaq 0xbe9623(%rip), %rcx # 0x10b88e8
movq %rcx, (%rax)
movq -0x10(%rbp), %rc... | /kaydenl[P]VK-GL-CTS/framework/platform/X11/tcuX11Xcb.cpp |
tcu::x11::XcbWindow::setDimensions(int, int) | void XcbWindow::setDimensions (int width, int height)
{
const uint32_t values[] = {static_cast<uint32_t >(width), static_cast<uint32_t >(height)};
xcb_void_cookie_t result;
xcb_connection_t* display = m_display.getConnection();
result = xcb_configure_window(display, m_window, XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movq 0x10(%rax), %rdi
callq 0x4ce810
movq %rax, %rcx
movq -0x50(%rbp), %r... | /kaydenl[P]VK-GL-CTS/framework/platform/X11/tcuX11Xcb.cpp |
tcu::x11::glx::GlxContextFactory::GlxContextFactory(tcu::x11::EventState&) | GlxContextFactory::GlxContextFactory (EventState& eventState)
: glu::ContextFactory ("glx", "X11 GLX OpenGL Context")
, m_glXCreateContextAttribsARB (
reinterpret_cast<PFNGLXCREATECONTEXTATTRIBSARBPROC>(
TCU_CHECK_GLX(
glXGetProcAddress(
reinterpret_cast<const GLubyte*>("glXCreateContextAttribsARB")))... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4cc080
movq -0x78(%rbp), %rdx
leaq 0x932bcd(%rip), %rsi # 0xe02420
leaq -0x30(%rbp), %rdi
callq 0x4d20b0
jmp 0x4cf85e
leaq -0x69(... | /kaydenl[P]VK-GL-CTS/framework/platform/X11/tcuX11GlxPlatform.cpp |
tcu::x11::glx::GlxDisplay::GlxDisplay(tcu::x11::EventState&, char const*) | GlxDisplay::GlxDisplay (EventState& eventState, const char* name)
: XlibDisplay (eventState, name)
{
const Bool supported = glXQueryExtension(m_display, &m_errorBase, &m_eventBase);
if (!supported)
TCU_THROW(NotSupportedError, "GLX protocol not supported by X server");
TCU_CHECK_GLX(glXQueryVersion(m_display, &m... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x280(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4d5440
movq -0x280(%rbp), %rdi
leaq 0xbe8eb3(%rip), %rax # 0x10b8a70
movq %rax,... | /kaydenl[P]VK-GL-CTS/framework/platform/X11/tcuX11GlxPlatform.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.