name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
ncnn::Input::Input() | Input::Input()
{
one_blob_only = true;
support_inplace = true;
support_vulkan = true;
support_packing = true;
support_bf16_storage = true;
support_image_storage = true;
} | pushq %rbx
movq %rdi, %rbx
callq 0x5c026
leaq 0x24b578(%rip), %rax # 0x44f978
movq %rax, (%rbx)
movb $0x1, %al
movb %al, 0xf(%rbx)
movb %al, 0xc(%rbx)
movl $0x1010101, 0x8(%rbx) # imm = 0x1010101
popq %rbx
retq
| /ysh329[P]ncnn/src/layer/input.cpp |
ncnn::LRN::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int LRN::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
size_t elemsize = bottom_top_blob.elemsize;
int size = w * h;
// squared values with local_size padding
Mat square_blob;
square_blob.create(w, h, channels, elemsize, opt.workspace_allocator);
if (square_blob.empty())
return -100;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = bottom_top_blob.channel(q);
float* outptr = square_blob.channel(q);
for (int i = 0; i < size; i++)
{
outptr[i] = ptr[i] * ptr[i];
}
}
if (region_type == NormRegion_ACROSS_CHANNELS)
{
Mat square_sum;
square_sum.create(w, h, channels, elemsize, opt.workspace_allocator);
if (square_sum.empty())
return -100;
square_sum.fill(0.f);
const float alpha_div_size = alpha / local_size;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
// square sum
float* ssptr = square_sum.channel(q);
for (int p = q - local_size / 2; p <= q + local_size / 2; p++)
{
if (p < 0 || p >= channels)
continue;
const float* sptr = square_blob.channel(p);
for (int i = 0; i < size; i++)
{
ssptr[i] += sptr[i];
}
}
float* ptr = bottom_top_blob.channel(q);
for (int i = 0; i < size; i++)
{
ptr[i] = static_cast<float>(ptr[i] * pow(bias + alpha_div_size * ssptr[i], -beta));
}
}
}
else if (region_type == NormRegion_WITHIN_CHANNEL)
{
int outw = w;
int outh = h;
Mat square_blob_bordered = square_blob;
int pad = local_size / 2;
if (pad > 0)
{
Option opt_b = opt;
opt_b.blob_allocator = opt.workspace_allocator;
opt_b.use_packing_layout = false;
copy_make_border(square_blob, square_blob_bordered, pad, local_size - pad - 1, pad, local_size - pad - 1, BORDER_CONSTANT, 0.f, opt_b);
if (square_blob_bordered.empty())
return -100;
w = square_blob_bordered.w;
h = square_blob_bordered.h;
}
const int maxk = local_size * local_size;
const float alpha_div_size = alpha / maxk;
// norm window offsets
std::vector<int> _space_ofs(maxk);
int* space_ofs = &_space_ofs[0];
{
int p1 = 0;
int p2 = 0;
int gap = w - local_size;
for (int i = 0; i < local_size; i++)
{
for (int j = 0; j < local_size; j++)
{
space_ofs[p1] = p2;
p1++;
p2++;
}
p2 += gap;
}
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
float* ptr = bottom_top_blob.channel(q);
const Mat m = square_blob_bordered.channel(q);
for (int i = 0; i < outh; i++)
{
for (int j = 0; j < outw; j++)
{
const float* sptr = m.row(i) + j;
float ss = 0.f;
for (int k = 0; k < maxk; k++)
{
float val = sptr[space_ofs[k]];
ss += val;
}
ptr[j] = static_cast<float>(ptr[j] * pow(bias + alpha_div_size * ss, -beta));
}
ptr += outw;
}
}
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %rbp
movl 0x2c(%rsi), %esi
movl 0x30(%rbp), %ecx
movl 0x38(%rbp), %r13d
movq 0x10(%rbp), %r15
leaq 0x90(%rsp), %rax
andq $0x0, 0x40(%rax)
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movaps %xmm0, 0x20(%rax)
movups %xmm0, 0x2c(%rax)
movq 0x10(%rdx), %r9
movq %rax, %rdi
movq %rsi, %r12
movq %rcx, (%rsp)
movl %ecx, %edx
movl %r13d, %ecx
movq %r15, %r8
callq 0x6ec8c
movq 0x90(%rsp), %rcx
pushq $-0x64
popq %r10
testq %rcx, %rcx
je 0x204808
movq 0xd0(%rsp), %rdx
movslq 0xc8(%rsp), %rax
movq %rdx, %rsi
imulq %rax, %rsi
testq %rsi, %rsi
je 0x204808
movq %r15, %r11
movq %r14, 0x18(%rsp)
movq %r12, %rsi
movslq %esi, %rdi
movq %rdi, 0x78(%rsp)
movq (%rsp), %r14
imull %esi, %r14d
movq (%rbp), %rsi
movq 0x40(%rbp), %rdi
imulq 0xa0(%rsp), %rdx
xorl %r8d, %r8d
testl %r14d, %r14d
cmovlel %r8d, %r14d
testl %r13d, %r13d
movl $0x0, %r15d
cmovgl %r13d, %r15d
imulq 0x10(%rbp), %rdi
cmpq %r15, %r8
je 0x204849
xorl %r9d, %r9d
cmpq %r9, %r14
je 0x2047fd
movss (%rsi,%r9,4), %xmm0
mulss %xmm0, %xmm0
movss %xmm0, (%rcx,%r9,4)
incq %r9
jmp 0x2047e3
incq %r8
addq %rdx, %rcx
addq %rdi, %rsi
jmp 0x2047db
movl %r10d, %r14d
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x2049f4
lock
decl (%rax)
jne 0x2049f4
movq 0x90(%rsp), %rsi
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x2049ec
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x2049f4
movl 0xd0(%rbx), %ecx
testl %ecx, %ecx
je 0x204977
xorl %r14d, %r14d
cmpl $0x1, %ecx
jne 0x20480b
movq 0x90(%rsp), %rdx
movq 0x98(%rsp), %rcx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movq 0xa0(%rsp), %rdx
movq %rdx, 0x30(%rsp)
movl 0xa8(%rsp), %edx
movl %edx, 0x38(%rsp)
movq 0xb0(%rsp), %rdx
movq %rdx, 0x40(%rsp)
movups 0xb8(%rsp), %xmm0
movups %xmm0, 0x48(%rsp)
movl %eax, 0x58(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x60(%rsp)
testq %rcx, %rcx
je 0x2048c4
lock
incl (%rcx)
movl 0xd4(%rbx), %r13d
cmpl $0x2, %r13d
jl 0x204a41
movl %r10d, %r14d
movl %r13d, %edx
shrl %edx
movq 0x18(%rsp), %r11
movups (%r11), %xmm0
movups 0x10(%r11), %xmm1
movups 0x20(%r11), %xmm2
movups 0x30(%r11), %xmm3
leaq 0x110(%rsp), %rax
movaps %xmm3, 0x30(%rax)
movaps %xmm2, 0x20(%rax)
movaps %xmm1, 0x10(%rax)
movaps %xmm0, (%rax)
movq 0x10(%r11), %rcx
movq %rcx, 0x8(%rax)
movb $0x0, 0x27(%rax)
movl %edx, %ecx
notl %ecx
addl %r13d, %ecx
leaq 0x90(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorps %xmm0, %xmm0
movl %edx, %r8d
movl %ecx, %r9d
pushq %rax
pushq $0x0
callq 0x6fae8
popq %rax
popq %rcx
cmpq $0x0, 0x20(%rsp)
movl %r14d, %ecx
je 0x204e09
movslq 0x58(%rsp), %rax
imulq 0x60(%rsp), %rax
testq %rax, %rax
je 0x204e09
movq %rbp, 0x10(%rsp)
movl 0x4c(%rsp), %ebp
movl 0xd4(%rbx), %r13d
jmp 0x204a49
leaq 0x20(%rsp), %rdi
andq $0x0, 0x40(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movups %xmm0, 0xc(%rdi)
movaps %xmm0, 0x20(%rdi)
movups %xmm0, 0x2c(%rdi)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %r9
movl %r12d, %esi
movq (%rsp), %rdx
movl %r13d, %ecx
movq %r11, %r8
callq 0x6ec8c
movq 0x20(%rsp), %rax
testq %rax, %rax
pushq $-0x64
popq %rdi
je 0x204a09
movq 0x60(%rsp), %rcx
movslq 0x58(%rsp), %rdx
movq %rcx, %rsi
imulq %rdx, %rsi
testq %rsi, %rsi
je 0x204a09
imull %edx, %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpl %edx, %ecx
je 0x204c8a
andl $0x0, (%rax,%rdx,4)
incq %rdx
jmp 0x2049db
movq %rsi, %rdi
callq 0x573d0
movl %r14d, %eax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x204e3f
lock
decl (%rax)
jne 0x204e3f
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x204e34
movq (%rdi), %rax
callq *0x18(%rax)
pushq $-0x64
popq %rdi
jmp 0x204e3f
movq %rbp, 0x10(%rsp)
movl %r12d, %ebp
imull %r13d, %r13d
movss 0xd8(%rbx), %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r13, %rsi
callq 0x87f1c
cvtsi2ss %r13d, %xmm0
movq 0x110(%rsp), %r14
movl 0xd4(%rbx), %ecx
subl %ecx, %ebp
xorl %eax, %eax
xorl %edx, %edx
xorl %esi, %esi
cmpl %ecx, %esi
jge 0x204abc
cltq
leaq (%r14,%rax,4), %r8
movl %edx, %r9d
xorl %edi, %edi
cmpl %ecx, %edi
jge 0x204ab1
leaq (%r9,%rdi), %rcx
movl %ecx, (%r8,%rdi,4)
movl 0xd4(%rbx), %ecx
incq %rdi
jmp 0x204a9a
addl %ebp, %edx
addl %edi, %edx
incl %esi
addq %rdi, %rax
jmp 0x204a8b
movq %rbx, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x40(%rcx), %rax
imulq 0x10(%rcx), %rax
movq %rax, 0xf8(%rsp)
movslq 0x4c(%rsp), %rdx
movq 0x30(%rsp), %rax
movq 0x60(%rsp), %rsi
imulq %rax, %rsi
movq %rsi, 0xf0(%rsp)
imulq %rax, %rdx
movq %rdx, 0x108(%rsp)
xorl %eax, %eax
movq %r12, %rbx
testl %ebx, %ebx
cmovlel %eax, %ebx
movq (%rcx), %rcx
movq %rcx, 0xe8(%rsp)
movq (%rsp), %r12
testl %r12d, %r12d
cmovlel %eax, %r12d
movq %r12, (%rsp)
xorl %eax, %eax
movq 0x20(%rsp), %rcx
movq %rcx, 0xe0(%rsp)
movss 0x1c0cfb(%rip), %xmm1 # 0x3c5834
divss %xmm0, %xmm1
movss %xmm1, 0x10(%rsp)
movq %r15, 0x70(%rsp)
cmpq %r15, %rax
je 0x204c48
movq 0xf8(%rsp), %r12
imulq %rax, %r12
addq 0xe8(%rsp), %r12
movq 0xf0(%rsp), %rcx
movq %rax, 0x100(%rsp)
imulq %rax, %rcx
addq 0xe0(%rsp), %rcx
movq %rcx, 0x80(%rsp)
xorl %eax, %eax
cmpq (%rsp), %rax
je 0x204c33
movq 0x108(%rsp), %rbp
movq %rax, 0x88(%rsp)
imulq %rax, %rbp
addq 0x80(%rsp), %rbp
xorl %r15d, %r15d
cmpq %rbx, %r15
je 0x204c1a
leaq (,%r15,4), %rax
addq %rbp, %rax
xorps %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %r13
je 0x204bdc
movslq (%r14,%rcx,4), %rdx
addss (%rax,%rdx,4), %xmm0
incq %rcx
jmp 0x204bc9
mulss 0x8(%rsp), %xmm0
mulss 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
addss 0xe0(%rax), %xmm0
movss 0xdc(%rax), %xmm1
xorps 0x1c01cc(%rip), %xmm1 # 0x3c4dd0
callq 0x570e0
mulss (%r12,%r15,4), %xmm0
movss %xmm0, (%r12,%r15,4)
incq %r15
jmp 0x204bb4
movq 0x78(%rsp), %rax
leaq (%r12,%rax,4), %r12
movq 0x88(%rsp), %rax
incq %rax
jmp 0x204b8b
movq 0x100(%rsp), %rax
incq %rax
movq 0x70(%rsp), %r15
jmp 0x204b48
leaq 0x110(%rsp), %rdi
callq 0x6d4aa
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x204e4f
lock
decl (%rax)
jne 0x204e4f
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x204e32
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x204e4f
movq %r15, 0x70(%rsp)
movl 0xd4(%rbx), %ecx
cvtsi2ss %ecx, %xmm0
movss 0xd8(%rbx), %xmm1
movss %xmm1, 0x18(%rsp)
movq 0x20(%rsp), %r12
movq 0x60(%rsp), %rdi
pushq $-0x2
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
movq %rax, (%rsp)
pushq $0x2
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
movq (%rbp), %r15
movq 0x40(%rbp), %rcx
cltq
movq %rax, 0x78(%rsp)
movss 0x1c0b58(%rip), %xmm1 # 0x3c5834
divss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
imulq 0x30(%rsp), %rdi
movq %rdi, 0x88(%rsp)
imulq 0x10(%rbp), %rcx
movq %rcx, 0x80(%rsp)
xorl %edx, %edx
cmpq 0x70(%rsp), %rdx
je 0x204de3
movq (%rsp), %rax
addl %edx, %eax
movq 0x78(%rsp), %rcx
movq %rdx, 0x10(%rsp)
addq %rdx, %rcx
movq 0x90(%rsp), %rdx
movq 0xd0(%rsp), %rsi
imulq 0xa0(%rsp), %rsi
movslq %eax, %rdi
cmpq %rdi, %rcx
jl 0x204d80
testl %eax, %eax
sets %dil
cmpl %r13d, %eax
setge %r8b
orb %dil, %r8b
jne 0x204d7c
movl %eax, %edi
imulq %rsi, %rdi
addq %rdx, %rdi
xorl %r8d, %r8d
cmpq %r8, %r14
je 0x204d7c
movss (%r12,%r8,4), %xmm0
addss (%rdi,%r8,4), %xmm0
movss %xmm0, (%r12,%r8,4)
incq %r8
jmp 0x204d60
incl %eax
jmp 0x204d3a
xorl %ebp, %ebp
cmpq %rbp, %r14
je 0x204dc6
movss (%r12,%rbp,4), %xmm0
mulss 0x18(%rsp), %xmm0
mulss 0x8(%rsp), %xmm0
addss 0xe0(%rbx), %xmm0
movss 0xdc(%rbx), %xmm1
xorps 0x1c0020(%rip), %xmm1 # 0x3c4dd0
callq 0x570e0
mulss (%r15,%rbp,4), %xmm0
movss %xmm0, (%r15,%rbp,4)
incq %rbp
jmp 0x204d82
movq 0x10(%rsp), %rdx
incq %rdx
addq 0x88(%rsp), %r12
addq 0x80(%rsp), %r15
jmp 0x204d03
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x204e4f
lock
decl (%rax)
jne 0x204e4f
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x204e47
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x204e4f
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x204e62
lock
decl (%rax)
jne 0x204e62
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x204e57
movq (%rdi), %rax
callq *0x18(%rax)
movl %r14d, %ecx
jmp 0x204e62
jmp 0x204e47
movq %rsi, %rdi
callq 0x573d0
pushq $-0x64
popq %rdi
movl %edi, %r14d
jmp 0x20480b
movq %rsi, %rdi
callq 0x573d0
xorl %r14d, %r14d
jmp 0x20480b
movq %rsi, %rdi
callq 0x573d0
movl %r14d, %ecx
movl %ecx, %r14d
jmp 0x20480b
jmp 0x204f26
jmp 0x204f26
jmp 0x204f26
jmp 0x204f26
jmp 0x204e80
movq %rax, %rbx
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x204ee7
lock
decl (%rax)
jne 0x204ee7
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
jne 0x204ea3
jmp 0x204ece
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x204ee7
jmp 0x204f26
movq %rax, %rbx
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x204ee7
lock
decl (%rax)
jne 0x204ee7
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
jne 0x204ed8
movq %rsi, %rdi
callq 0x573d0
jmp 0x204ee7
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x204ee7
jmp 0x204f26
jmp 0x204f26
movq %rax, %rbx
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x204f1e
lock
decl (%rax)
jne 0x204f1e
movq 0x90(%rsp), %rsi
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
jne 0x204f18
movq %rsi, %rdi
callq 0x573d0
jmp 0x204f1e
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x57330
movq %rax, %rdi
callq 0x582a4
| /ysh329[P]ncnn/src/layer/lrn.cpp |
virtual thunk to ncnn::Pooling_x86::create_pipeline(ncnn::Option const&) | int Pooling_x86::create_pipeline(const Option& /*opt*/)
{
if (adaptive_pooling)
{
support_packing = false;
support_bf16_storage = false;
support_fp16_storage = false;
support_int8_storage = false;
support_tensor_storage = false;
}
return 0;
} | pushq %rax
movq (%rdi), %rax
addq -0x30(%rax), %rdi
callq 0x209a4c
xorl %eax, %eax
popq %rcx
retq
nop
| /ysh329[P]ncnn/src/layer/x86/pooling_x86.cpp |
ncnn::Pooling_x86::forward(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) const | int Pooling_x86::forward(const Mat& bottom_blob, Mat& top_blob, const Option& opt) const
{
// max value in NxN window
// avg value in NxN window
if (adaptive_pooling)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
#if __SSE2__
int elempack = bottom_blob.elempack;
int w = bottom_blob.w;
int h = bottom_blob.h;
int channels = bottom_blob.c;
size_t elemsize = bottom_blob.elemsize;
#if __AVX__
#if __AVX512F__
if (elempack == 16)
{
if (global_pooling)
{
top_blob.create(channels, elemsize, elempack, opt.blob_allocator);
if (top_blob.empty())
return -100;
int size = w * h;
if (pooling_type == PoolMethod_MAX)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = bottom_blob.channel(q);
__m512 _max = _mm512_loadu_ps(ptr);
for (int i = 0; i < size; i++)
{
__m512 _val = _mm512_loadu_ps(ptr);
_max = _mm512_max_ps(_max, _val);
ptr += 16;
}
float* outptr = top_blob;
_mm512_storeu_ps(outptr + q * 16, _max);
}
}
else if (pooling_type == PoolMethod_AVE)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = bottom_blob.channel(q);
__m512 _sum = _mm512_set1_ps(0.f);
for (int i = 0; i < size; i++)
{
__m512 _val = _mm512_loadu_ps(ptr);
_sum = _mm512_add_ps(_sum, _val);
ptr += 16;
}
__m512 _inv_size = _mm512_set1_ps(1.f / size);
__m512 _avg = _mm512_mul_ps(_sum, _inv_size);
float* outptr = top_blob;
_mm512_storeu_ps(outptr + q * 16, _avg);
}
}
return 0;
}
Mat bottom_blob_bordered;
make_padding(bottom_blob, bottom_blob_bordered, opt);
if (bottom_blob_bordered.empty())
return -100;
w = bottom_blob_bordered.w;
h = bottom_blob_bordered.h;
int outw = (w - kernel_w) / stride_w + 1;
int outh = (h - kernel_h) / stride_h + 1;
top_blob.create(outw, outh, channels, elemsize, elempack, opt.blob_allocator);
if (top_blob.empty())
return -100;
const int maxk = kernel_w * kernel_h;
// kernel offsets
std::vector<int> _space_ofs(maxk);
int* space_ofs = &_space_ofs[0];
{
int p1 = 0;
int p2 = 0;
int gap = w - kernel_w;
for (int i = 0; i < kernel_h; i++)
{
for (int j = 0; j < kernel_w; j++)
{
space_ofs[p1] = p2;
p1++;
p2++;
}
p2 += gap;
}
}
if (pooling_type == PoolMethod_MAX)
{
if (kernel_w == 2 && kernel_h == 2 && stride_w == 2 && stride_h == 2)
{
pooling2x2s2_max_pack16_avx512(bottom_blob_bordered, top_blob, opt);
return 0;
}
if (kernel_w == 3 && kernel_h == 3 && stride_w == 2 && stride_h == 2)
{
pooling3x3s2_max_pack16_avx512(bottom_blob_bordered, top_blob, opt);
return 0;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
for (int i = 0; i < outh; i++)
{
for (int j = 0; j < outw; j++)
{
const float* sptr = m.row(i * stride_h) + j * stride_w * 16;
__m512 _max = _mm512_loadu_ps(sptr);
for (int k = 0; k < maxk; k++)
{
__m512 _val = _mm512_loadu_ps(sptr + space_ofs[k] * 16);
_max = _mm512_max_ps(_max, _val);
}
_mm512_storeu_ps(outptr, _max);
outptr += 16;
}
}
}
}
else if (pooling_type == PoolMethod_AVE)
{
if (avgpool_count_include_pad == 0)
{
int wtailpad = 0;
int htailpad = 0;
if (pad_mode == 0) // full padding
{
wtailpad = bottom_blob_bordered.w - bottom_blob.w - pad_left - pad_right;
htailpad = bottom_blob_bordered.h - bottom_blob.h - pad_top - pad_bottom;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
for (int i = 0; i < outh; i++)
{
int sy0 = i * stride_h;
for (int j = 0; j < outw; j++)
{
int sx0 = j * stride_w;
__m512 _sum = _mm512_set1_ps(0.f);
int area = 0;
for (int ki = 0; ki < kernel_h; ki++)
{
int sy = sy0 + ki;
if (sy < pad_top)
continue;
if (sy >= h - pad_bottom - htailpad)
break;
for (int kj = 0; kj < kernel_w; kj++)
{
int sx = sx0 + kj;
if (sx < pad_left)
continue;
if (sx >= w - pad_right - wtailpad)
break;
__m512 _val = _mm512_loadu_ps(m.row(sy) + sx * 16);
_sum = _mm512_add_ps(_sum, _val);
area += 1;
}
}
__m512 _inv_area = _mm512_set1_ps(1.f / area);
__m512 _avg = _mm512_mul_ps(_sum, _inv_area);
_mm512_storeu_ps(outptr, _avg);
outptr += 16;
}
}
}
}
else // if (avgpool_count_include_pad == 1)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
__m512 _inv_maxk = _mm512_set1_ps(1.f / maxk);
for (int i = 0; i < outh; i++)
{
for (int j = 0; j < outw; j++)
{
const float* sptr = m.row(i * stride_h) + j * stride_w * 16;
__m512 _sum = _mm512_set1_ps(0.f);
for (int k = 0; k < maxk; k++)
{
__m512 _val = _mm512_loadu_ps(sptr + space_ofs[k] * 16);
_sum = _mm512_add_ps(_sum, _val);
}
__m512 _avg = _mm512_mul_ps(_sum, _inv_maxk);
_mm512_storeu_ps(outptr, _avg);
outptr += 16;
}
}
}
}
}
return 0;
}
#endif // __AVX512F__
// NCNN_LOGE("Pooling input %d x %d pad = %d %d %d %d ksize=%d %d stride=%d %d", w, h, pad_left, pad_right, pad_top, pad_bottom, kernel_w, kernel_h, stride_w, stride_h);
if (elempack == 8)
{
if (global_pooling)
{
top_blob.create(channels, elemsize, elempack, opt.blob_allocator);
if (top_blob.empty())
return -100;
int size = w * h;
if (pooling_type == PoolMethod_MAX)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = bottom_blob.channel(q);
__m256 _max = _mm256_loadu_ps(ptr);
for (int i = 0; i < size; i++)
{
__m256 _val = _mm256_loadu_ps(ptr);
_max = _mm256_max_ps(_max, _val);
ptr += 8;
}
float* outptr = top_blob;
_mm256_storeu_ps(outptr + q * 8, _max);
}
}
else if (pooling_type == PoolMethod_AVE)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = bottom_blob.channel(q);
__m256 _sum = _mm256_set1_ps(0.f);
for (int i = 0; i < size; i++)
{
__m256 _val = _mm256_loadu_ps(ptr);
_sum = _mm256_add_ps(_sum, _val);
ptr += 8;
}
__m256 _inv_size = _mm256_set1_ps(1.f / size);
__m256 _avg = _mm256_mul_ps(_sum, _inv_size);
float* outptr = top_blob;
_mm256_storeu_ps(outptr + q * 8, _avg);
}
}
return 0;
}
Mat bottom_blob_bordered;
make_padding(bottom_blob, bottom_blob_bordered, opt);
if (bottom_blob_bordered.empty())
return -100;
w = bottom_blob_bordered.w;
h = bottom_blob_bordered.h;
int outw = (w - kernel_w) / stride_w + 1;
int outh = (h - kernel_h) / stride_h + 1;
top_blob.create(outw, outh, channels, elemsize, elempack, opt.blob_allocator);
if (top_blob.empty())
return -100;
const int maxk = kernel_w * kernel_h;
// kernel offsets
std::vector<int> _space_ofs(maxk);
int* space_ofs = &_space_ofs[0];
{
int p1 = 0;
int p2 = 0;
int gap = w - kernel_w;
for (int i = 0; i < kernel_h; i++)
{
for (int j = 0; j < kernel_w; j++)
{
space_ofs[p1] = p2;
p1++;
p2++;
}
p2 += gap;
}
}
if (pooling_type == PoolMethod_MAX)
{
if (kernel_w == 2 && kernel_h == 2 && stride_w == 2 && stride_h == 2)
{
pooling2x2s2_max_pack8_avx(bottom_blob_bordered, top_blob, opt);
return 0;
}
if (kernel_w == 3 && kernel_h == 3 && stride_w == 2 && stride_h == 2)
{
pooling3x3s2_max_pack8_avx(bottom_blob_bordered, top_blob, opt);
return 0;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
for (int i = 0; i < outh; i++)
{
for (int j = 0; j < outw; j++)
{
const float* sptr = m.row(i * stride_h) + j * stride_w * 8;
__m256 _max = _mm256_loadu_ps(sptr);
for (int k = 0; k < maxk; k++)
{
__m256 _val = _mm256_loadu_ps(sptr + space_ofs[k] * 8);
_max = _mm256_max_ps(_max, _val);
}
_mm256_storeu_ps(outptr + j * 8, _max);
}
outptr += outw * 8;
}
}
}
else if (pooling_type == PoolMethod_AVE)
{
if (avgpool_count_include_pad == 0)
{
int wtailpad = 0;
int htailpad = 0;
if (pad_mode == 0) // full padding
{
wtailpad = bottom_blob_bordered.w - bottom_blob.w - pad_left - pad_right;
htailpad = bottom_blob_bordered.h - bottom_blob.h - pad_top - pad_bottom;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
for (int i = 0; i < outh; i++)
{
int sy0 = i * stride_h;
for (int j = 0; j < outw; j++)
{
int sx0 = j * stride_w;
__m256 _sum = _mm256_set1_ps(0.f);
int area = 0;
for (int ki = 0; ki < kernel_h; ki++)
{
int sy = sy0 + ki;
if (sy < pad_top)
continue;
if (sy >= h - pad_bottom - htailpad)
break;
for (int kj = 0; kj < kernel_w; kj++)
{
int sx = sx0 + kj;
if (sx < pad_left)
continue;
if (sx >= w - pad_right - wtailpad)
break;
__m256 _val = _mm256_loadu_ps(m.row(sy) + sx * 8);
_sum = _mm256_add_ps(_sum, _val);
area += 1;
}
}
__m256 _inv_area = _mm256_set1_ps(1.f / area);
__m256 _avg = _mm256_mul_ps(_sum, _inv_area);
_mm256_storeu_ps(outptr + j * 8, _avg);
}
outptr += outw * 8;
}
}
}
else // if (avgpool_count_include_pad == 1)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
__m256 _inv_maxk = _mm256_set1_ps(1.f / maxk);
for (int i = 0; i < outh; i++)
{
for (int j = 0; j < outw; j++)
{
const float* sptr = m.row(i * stride_h) + j * stride_w * 8;
__m256 _sum = _mm256_set1_ps(0.f);
for (int k = 0; k < maxk; k++)
{
__m256 _val = _mm256_loadu_ps(sptr + space_ofs[k] * 8);
_sum = _mm256_add_ps(_sum, _val);
}
__m256 _avg = _mm256_mul_ps(_sum, _inv_maxk);
_mm256_storeu_ps(outptr + j * 8, _avg);
}
outptr += outw * 8;
}
}
}
}
return 0;
}
#endif // __AVX__
if (elempack == 4)
{
if (global_pooling)
{
top_blob.create(channels, elemsize, elempack, opt.blob_allocator);
if (top_blob.empty())
return -100;
int size = w * h;
if (pooling_type == PoolMethod_MAX)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = bottom_blob.channel(q);
__m128 _max = _mm_loadu_ps(ptr);
for (int i = 0; i < size; i++)
{
__m128 _val = _mm_loadu_ps(ptr);
_max = _mm_max_ps(_max, _val);
ptr += 4;
}
float* outptr = top_blob;
_mm_storeu_ps(outptr + q * 4, _max);
}
}
else if (pooling_type == PoolMethod_AVE)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const float* ptr = bottom_blob.channel(q);
__m128 _sum = _mm_set1_ps(0.f);
for (int i = 0; i < size; i++)
{
__m128 _val = _mm_loadu_ps(ptr);
_sum = _mm_add_ps(_sum, _val);
ptr += 4;
}
__m128 _inv_size = _mm_set1_ps(1.f / size);
__m128 _avg = _mm_mul_ps(_sum, _inv_size);
float* outptr = top_blob;
_mm_storeu_ps(outptr + q * 4, _avg);
}
}
return 0;
}
Mat bottom_blob_bordered;
make_padding(bottom_blob, bottom_blob_bordered, opt);
if (bottom_blob_bordered.empty())
return -100;
w = bottom_blob_bordered.w;
h = bottom_blob_bordered.h;
int outw = (w - kernel_w) / stride_w + 1;
int outh = (h - kernel_h) / stride_h + 1;
top_blob.create(outw, outh, channels, elemsize, elempack, opt.blob_allocator);
if (top_blob.empty())
return -100;
const int maxk = kernel_w * kernel_h;
// kernel offsets
std::vector<int> _space_ofs(maxk);
int* space_ofs = &_space_ofs[0];
{
int p1 = 0;
int p2 = 0;
int gap = w - kernel_w;
for (int i = 0; i < kernel_h; i++)
{
for (int j = 0; j < kernel_w; j++)
{
space_ofs[p1] = p2;
p1++;
p2++;
}
p2 += gap;
}
}
if (pooling_type == PoolMethod_MAX)
{
if (kernel_w == 2 && kernel_h == 2 && stride_w == 2 && stride_h == 2)
{
pooling2x2s2_max_pack4_sse(bottom_blob_bordered, top_blob, opt);
return 0;
}
if (kernel_w == 3 && kernel_h == 3 && stride_w == 2 && stride_h == 2)
{
pooling3x3s2_max_pack4_sse(bottom_blob_bordered, top_blob, opt);
return 0;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
for (int i = 0; i < outh; i++)
{
for (int j = 0; j < outw; j++)
{
const float* sptr = m.row(i * stride_h) + j * stride_w * 4;
__m128 _max = _mm_loadu_ps(sptr);
for (int k = 0; k < maxk; k++)
{
__m128 _val = _mm_loadu_ps(sptr + space_ofs[k] * 4);
_max = _mm_max_ps(_max, _val);
}
_mm_storeu_ps(outptr + j * 4, _max);
}
outptr += outw * 4;
}
}
}
else if (pooling_type == PoolMethod_AVE)
{
if (avgpool_count_include_pad == 0)
{
int wtailpad = 0;
int htailpad = 0;
if (pad_mode == 0) // full padding
{
wtailpad = bottom_blob_bordered.w - bottom_blob.w - pad_left - pad_right;
htailpad = bottom_blob_bordered.h - bottom_blob.h - pad_top - pad_bottom;
}
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
for (int i = 0; i < outh; i++)
{
int sy0 = i * stride_h;
for (int j = 0; j < outw; j++)
{
int sx0 = j * stride_w;
__m128 _sum = _mm_set1_ps(0.f);
int area = 0;
for (int ki = 0; ki < kernel_h; ki++)
{
int sy = sy0 + ki;
if (sy < pad_top)
continue;
if (sy >= h - pad_bottom - htailpad)
break;
for (int kj = 0; kj < kernel_w; kj++)
{
int sx = sx0 + kj;
if (sx < pad_left)
continue;
if (sx >= w - pad_right - wtailpad)
break;
__m128 _val = _mm_loadu_ps(m.row(sy) + sx * 4);
_sum = _mm_add_ps(_sum, _val);
area += 1;
}
}
__m128 _inv_area = _mm_set1_ps(1.f / area);
__m128 _avg = _mm_mul_ps(_sum, _inv_area);
_mm_storeu_ps(outptr + j * 4, _avg);
}
outptr += outw * 4;
}
}
}
else // if (avgpool_count_include_pad == 1)
{
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
const Mat m = bottom_blob_bordered.channel(q);
float* outptr = top_blob.channel(q);
__m128 _inv_maxk = _mm_set1_ps(1.f / maxk);
for (int i = 0; i < outh; i++)
{
for (int j = 0; j < outw; j++)
{
const float* sptr = m.row(i * stride_h) + j * stride_w * 4;
__m128 _sum = _mm_set1_ps(0.f);
for (int k = 0; k < maxk; k++)
{
__m128 _val = _mm_loadu_ps(sptr + space_ofs[k] * 4);
_sum = _mm_add_ps(_sum, _val);
}
__m128 _avg = _mm_mul_ps(_sum, _inv_maxk);
_mm_storeu_ps(outptr + j * 4, _avg);
}
outptr += outw * 4;
}
}
}
}
return 0;
}
#endif // __SSE2__
if (kernel_w != kernel_h || stride_w != stride_h)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
const int stride = stride_w;
if (pooling_type != PoolMethod_MAX || stride != 2 || global_pooling == 1)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
#if __AVX__
const int kernel_size = kernel_w;
if (kernel_size != 2)
{
return Pooling::forward(bottom_blob, top_blob, opt);
}
Mat bottom_blob_bordered;
make_padding(bottom_blob, bottom_blob_bordered, opt);
if (bottom_blob_bordered.empty())
return -100;
w = bottom_blob_bordered.w;
h = bottom_blob_bordered.h;
int outw = (w - kernel_w) / stride_w + 1;
int outh = (h - kernel_h) / stride_h + 1;
top_blob.create(outw, outh, channels, elemsize, opt.blob_allocator);
if (top_blob.empty())
return -100;
if (kernel_size == 2)
pooling2x2s2_max_avx(bottom_blob_bordered, top_blob, opt);
return 0;
#else
return Pooling::forward(bottom_blob, top_blob, opt);
#endif
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %rbp
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
cmpl $0x0, 0x100(%r15,%rax)
je 0x209ae3
movq %r13, %rsi
movq %rbp, %rcx
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x208a7c
cmpl $0x4, 0x18(%r13)
jne 0x209be0
movq %rdx, 0x18(%rsp)
movl 0x38(%r13), %esi
movq 0x10(%r13), %r14
cmpl $0x0, 0xf4(%rdi)
movq %rsi, 0x10(%rsp)
je 0x209c26
movl 0x2c(%r13), %r12d
movl 0x30(%r13), %ebx
movq 0x8(%rbp), %r8
pushq $0x4
popq %rcx
movq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rdx
callq 0x6db56
cmpq $0x0, (%rbp)
je 0x209dad
movslq 0x38(%rbp), %rax
imulq 0x40(%rbp), %rax
testq %rax, %rax
pushq $-0x64
popq %rax
je 0x20a63b
imull %r12d, %ebx
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0xd0(%r15,%rax), %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x209db5
cmpl $0x1, %ecx
jne 0x20a63b
cvtsi2ss %ebx, %xmm1
movss 0x1bbcb6(%rip), %xmm0 # 0x3c5834
divss %xmm1, %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
movq 0x10(%rsp), %rsi
testl %esi, %esi
cmovlel %eax, %esi
xorl %edi, %edi
cmpq %rsi, %rdi
je 0x20a63b
movq 0x40(%r13), %rcx
imulq %rdi, %rcx
imulq 0x10(%r13), %rcx
addq (%r13), %rcx
xorps %xmm1, %xmm1
movl %ebx, %edx
subl $0x1, %edx
jb 0x209bc9
movups (%rcx), %xmm2
addps %xmm2, %xmm1
addq $0x10, %rcx
jmp 0x209bb8
mulps %xmm0, %xmm1
movq (%rbp), %rcx
movq %rdi, %rdx
shlq $0x4, %rdx
movups %xmm1, (%rcx,%rdx)
incq %rdi
jmp 0x209b99
movl 0xd4(%rdi), %eax
cmpl 0xd8(%rdi), %eax
jne 0x209ac7
movl 0xdc(%rdi), %eax
cmpl 0xe0(%rdi), %eax
jne 0x209ac7
cmpl $0x2, %eax
jne 0x209ac7
cmpl $0x0, 0xd0(%rdi)
jne 0x209ac7
cmpl $0x1, 0xf4(%rdi)
jmp 0x209ac7
leaq 0x40(%rsp), %rdx
andq $0x0, 0x40(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movups %xmm0, 0xc(%rdx)
movaps %xmm0, 0x20(%rdx)
movups %xmm0, 0x2c(%rdx)
movq %r13, %rsi
movq %rbp, %rcx
callq 0x2096aa
pushq $-0x64
popq %rax
cmpq $0x0, 0x40(%rsp)
movq 0x18(%rsp), %rdi
je 0x20a604
movslq 0x78(%rsp), %rcx
imulq 0x80(%rsp), %rcx
testq %rcx, %rcx
je 0x20a604
movq %rax, %r12
movl 0x6c(%rsp), %edx
movl 0x70(%rsp), %r8d
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl %edx, 0x28(%rsp)
movl %edx, %eax
subl 0xd4(%r15,%rcx), %eax
cltd
idivl 0xdc(%r15,%rcx)
movl %eax, %esi
movl %r8d, 0x98(%rsp)
movl %r8d, %eax
subl 0xd8(%r15,%rcx), %eax
cltd
idivl 0xe0(%r15,%rcx)
movq %rsi, 0x20(%rsp)
incl %esi
movq %rax, 0x90(%rsp)
leal 0x1(%rax), %edx
movq 0x8(%rbp), %rax
movq %rax, (%rsp)
pushq $0x4
popq %r9
movl %esi, 0x38(%rsp)
movq 0x10(%rsp), %rcx
movq %rdi, %rbx
movq %r14, %r8
callq 0x6dd6e
cmpq $0x0, (%rbx)
movq %r12, %rax
je 0x20a604
movslq 0x38(%rbx), %rcx
imulq 0x40(%rbx), %rcx
testq %rcx, %rcx
je 0x20a604
movq (%r15), %rax
movq -0x18(%rax), %rax
movslq 0xd4(%r15,%rax), %rcx
movslq 0xd8(%r15,%rax), %rbp
imulq %rcx, %rbp
leaq 0xe0(%rsp), %rdi
leaq 0x37(%rsp), %rdx
movq %rbp, %rsi
callq 0x87f1c
movq (%r15), %rcx
movq -0x18(%rcx), %rsi
movl 0x28(%rsp), %r14d
movl %r14d, %edx
subl 0xd4(%r15,%rsi), %edx
movq 0xe0(%rsp), %rax
xorl %edi, %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
movl 0xd8(%r15,%rsi), %r10d
cmpl %r10d, %r9d
jge 0x209e10
movslq %r8d, %r8
leaq (%rax,%r8,4), %r11
movl %edi, %ebx
xorl %r10d, %r10d
cmpl 0xd4(%r15,%rsi), %r10d
jge 0x209da0
leaq (%rbx,%r10), %rsi
movl %esi, (%r11,%r10,4)
movq -0x18(%rcx), %rsi
incq %r10
jmp 0x209d85
addl %edx, %edi
addl %r10d, %edi
incl %r9d
addq %r10, %r8
jmp 0x209d68
pushq $-0x64
popq %rax
jmp 0x20a63b
testl %ebx, %ebx
cmovlel %eax, %ebx
movq 0x10(%rsp), %rdi
testl %edi, %edi
cmovlel %eax, %edi
xorl %r8d, %r8d
cmpq %rdi, %r8
je 0x20a63b
movq 0x40(%r13), %rdx
imulq %r8, %rdx
imulq 0x10(%r13), %rdx
movq (%r13), %rsi
leaq (%rsi,%rdx), %rcx
movups (%rsi,%rdx), %xmm0
movl %ebx, %edx
subl $0x1, %edx
jb 0x209dfc
movups (%rcx), %xmm1
maxps %xmm1, %xmm0
addq $0x10, %rcx
jmp 0x209deb
movq (%rbp), %rcx
movq %r8, %rdx
shlq $0x4, %rdx
movups %xmm0, (%rcx,%rdx)
incq %r8
jmp 0x209dc7
movl 0xd0(%r15,%rsi), %ecx
testl %ecx, %ecx
je 0x209f5f
cmpl $0x1, %ecx
jne 0x20a5f5
cmpl $0x0, 0xfc(%r15,%rsi)
je 0x20a35a
cvtsi2ss %ebp, %xmm1
movss 0x1bb9f0(%rip), %xmm0 # 0x3c5834
divss %xmm1, %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movl 0x38(%rsp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
xorl %edx, %edx
testl %ebp, %ebp
cmovlel %edx, %ebp
movslq 0x20(%rsp), %rsi
movq 0x10(%rsp), %r12
testl %r12d, %r12d
cmovlel %edx, %r12d
movq %r12, 0x10(%rsp)
cmpq 0x10(%rsp), %rdx
je 0x20a5f5
movslq 0x6c(%rsp), %rdi
movq 0x80(%rsp), %r8
imulq %rdx, %r8
movq 0x50(%rsp), %r10
imulq %r10, %r8
addq 0x40(%rsp), %r8
movq %rdx, %r11
movq 0x18(%rsp), %rdx
movq 0x40(%rdx), %r9
movq %r11, 0x28(%rsp)
imulq %r11, %r9
imulq 0x10(%rdx), %r9
addq (%rdx), %r9
imulq %r10, %rdi
xorl %r10d, %r10d
cmpl 0x90(%rsp), %r10d
jg 0x209f52
movq (%r15), %r11
movslq %r10d, %rbx
xorl %r14d, %r14d
cmpq %rsi, %r14
jg 0x209f46
movq -0x18(%r11), %r12
movslq 0xe0(%r15,%r12), %r13
imulq %rbx, %r13
imulq %rdi, %r13
addq %r8, %r13
movl 0xdc(%r15,%r12), %r12d
imull %r14d, %r12d
shll $0x2, %r12d
movslq %r12d, %r12
leaq (,%r12,4), %r12
addq %r13, %r12
xorps %xmm1, %xmm1
xorl %r13d, %r13d
cmpq %r13, %rbp
je 0x209f32
movslq (%rax,%r13,4), %rdx
shlq $0x4, %rdx
movups (%r12,%rdx), %xmm2
addps %xmm2, %xmm1
incq %r13
jmp 0x209f18
mulps %xmm0, %xmm1
movq %r14, %r12
shlq $0x4, %r12
movups %xmm1, (%r9,%r12)
incq %r14
jmp 0x209ed8
leaq (%r9,%rcx,4), %r9
incl %r10d
jmp 0x209ec1
movq 0x28(%rsp), %rdx
incq %rdx
jmp 0x209e73
movl 0xd4(%r15,%rsi), %ecx
movl %ecx, %edx
xorl $0x2, %edx
movl %r10d, %edi
xorl $0x2, %edi
orl %edx, %edi
jne 0x20a067
cmpl $0x2, 0xdc(%r15,%rsi)
movq 0x18(%rsp), %rdx
jne 0x20a248
cmpl $0x2, 0xe0(%r15,%rsi)
jne 0x20a248
movl 0x6c(%rsp), %esi
movl 0x78(%rsp), %eax
movl 0x2c(%rdx), %ecx
movl 0x30(%rdx), %edx
subl %ecx, %esi
shll $0x3, %esi
movslq %esi, %rsi
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
testl %edx, %edx
cmovlel %edi, %edx
testl %eax, %eax
cmovlel %edi, %eax
shlq $0x2, %rsi
negq %rsi
cmpq %rax, %rdi
je 0x20a5f5
movq 0x80(%rsp), %r8
imulq %rdi, %r8
movq 0x50(%rsp), %r11
imulq %r11, %r8
addq 0x40(%rsp), %r8
movq 0x18(%rsp), %r10
movq 0x40(%r10), %r9
imulq %rdi, %r9
imulq 0x10(%r10), %r9
addq (%r10), %r9
movslq 0x6c(%rsp), %r10
imulq %r11, %r10
addq %r8, %r10
xorl %r11d, %r11d
cmpl %edx, %r11d
je 0x20a05f
xorl %ebx, %ebx
movq %rsi, %r14
movl %ecx, %ebp
subl $0x1, %ebp
jb 0x20a051
movups (%r8,%rbx,2), %xmm0
movups 0x10(%r8,%rbx,2), %xmm1
maxps %xmm0, %xmm1
movups (%r10,%rbx,2), %xmm0
movups 0x10(%r10,%rbx,2), %xmm2
maxps %xmm0, %xmm2
maxps %xmm1, %xmm2
movups %xmm2, (%r9,%rbx)
addq $-0x20, %r14
addq $0x10, %rbx
jmp 0x20a01e
subq %r14, %r8
subq %r14, %r10
incl %r11d
addq %rbx, %r9
jmp 0x20a012
incq %rdi
jmp 0x209fcb
xorl $0x3, %ecx
xorl $0x3, %r10d
orl %ecx, %r10d
movq 0x18(%rsp), %rdx
jne 0x20a248
cmpl $0x2, 0xdc(%r15,%rsi)
jne 0x20a248
cmpl $0x2, 0xe0(%r15,%rsi)
jne 0x20a248
movl 0x6c(%rsp), %esi
movl 0x78(%rsp), %eax
movl 0x2c(%rdx), %ecx
movl 0x30(%rdx), %edx
subl %ecx, %esi
shll $0x3, %esi
movslq %esi, %rsi
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
testl %eax, %eax
cmovlel %edi, %eax
shlq $0x2, %rsi
cmpq %rax, %rdi
je 0x20a5f5
movslq 0x6c(%rsp), %r11
movq 0x80(%rsp), %r8
imulq %rdi, %r8
movq 0x50(%rsp), %r10
imulq %r10, %r8
addq 0x40(%rsp), %r8
movq 0x18(%rsp), %rbx
movq 0x40(%rbx), %r9
imulq %rdi, %r9
imulq 0x10(%rbx), %r9
addq (%rbx), %r9
imulq %r10, %r11
leaq (%r8,%r11), %r10
leaq (%r8,%r11,2), %r11
xorl %ebx, %ebx
cmpl %edx, %ebx
je 0x20a240
xorl %r14d, %r14d
xorl %r15d, %r15d
leal 0x1(%r15), %ebp
cmpl %ecx, %ebp
jge 0x20a222
movups (%r8,%r14), %xmm0
movups 0x10(%r8,%r14), %xmm3
maxps %xmm0, %xmm3
movups 0x20(%r8,%r14), %xmm1
movups 0x30(%r8,%r14), %xmm4
movups (%r10,%r14), %xmm5
movups 0x10(%r10,%r14), %xmm6
movups 0x20(%r10,%r14), %xmm2
movups 0x30(%r10,%r14), %xmm0
maxps %xmm1, %xmm5
maxps %xmm3, %xmm5
maxps %xmm6, %xmm5
movups (%r11,%r14), %xmm3
movups 0x10(%r11,%r14), %xmm6
movups 0x20(%r11,%r14), %xmm7
movups 0x30(%r11,%r14), %xmm8
maxps %xmm2, %xmm3
maxps %xmm7, %xmm6
maxps %xmm3, %xmm6
maxps %xmm5, %xmm6
movups 0x40(%r8,%r14), %xmm3
maxps %xmm4, %xmm3
movups 0x40(%r10,%r14), %xmm4
movups 0x40(%r11,%r14), %xmm5
maxps %xmm4, %xmm5
movups %xmm6, (%r9)
maxps %xmm1, %xmm0
maxps %xmm3, %xmm0
maxps %xmm2, %xmm8
maxps %xmm7, %xmm5
maxps %xmm0, %xmm5
maxps %xmm8, %xmm5
movups %xmm5, 0x10(%r9)
addq $0x20, %r9
addl $0x2, %r15d
addq $0x40, %r14
jmp 0x20a119
movups (%r8,%r14), %xmm0
movups 0x10(%r8,%r14), %xmm1
maxps %xmm0, %xmm1
movups 0x20(%r8,%r14), %xmm0
movups (%r10,%r14), %xmm2
maxps %xmm0, %xmm2
maxps %xmm1, %xmm2
movups 0x10(%r10,%r14), %xmm0
maxps %xmm2, %xmm0
movups 0x20(%r10,%r14), %xmm1
movups (%r11,%r14), %xmm2
maxps %xmm1, %xmm2
movups 0x10(%r11,%r14), %xmm1
movups 0x20(%r11,%r14), %xmm3
maxps %xmm1, %xmm3
maxps %xmm2, %xmm3
maxps %xmm0, %xmm3
movups %xmm3, (%r9)
addq $0x10, %r9
incl %r15d
addq $0x20, %r14
cmpl %ecx, %r15d
jl 0x20a1c8
addq %rsi, %r8
addq %r14, %r8
addq %rsi, %r10
addq %r14, %r10
addq %rsi, %r11
addq %r14, %r11
incl %ebx
jmp 0x20a10b
incq %rdi
jmp 0x20a0c0
movl 0x38(%rsp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
xorl %edx, %edx
testl %ebp, %ebp
cmovlel %edx, %ebp
movslq 0x20(%rsp), %rsi
movq 0x10(%rsp), %r12
testl %r12d, %r12d
cmovlel %edx, %r12d
movq %r12, 0x10(%rsp)
cmpq 0x10(%rsp), %rdx
je 0x20a5f5
movslq 0x6c(%rsp), %rdi
movq 0x80(%rsp), %r8
imulq %rdx, %r8
movq 0x50(%rsp), %r10
imulq %r10, %r8
addq 0x40(%rsp), %r8
movq %rdx, %r11
movq 0x18(%rsp), %rdx
movq 0x40(%rdx), %r9
movq %r11, 0x28(%rsp)
imulq %r11, %r9
imulq 0x10(%rdx), %r9
addq (%rdx), %r9
imulq %r10, %rdi
xorl %r10d, %r10d
cmpl 0x90(%rsp), %r10d
jg 0x20a34d
movq (%r15), %r11
movslq %r10d, %rbx
xorl %r14d, %r14d
cmpq %rsi, %r14
jg 0x20a341
movq -0x18(%r11), %r12
movslq 0xe0(%r15,%r12), %r13
imulq %rbx, %r13
imulq %rdi, %r13
addq %r8, %r13
movl 0xdc(%r15,%r12), %r12d
imull %r14d, %r12d
shll $0x2, %r12d
movslq %r12d, %r12
leaq (,%r12,4), %r12
addq %r13, %r12
movups (%r12), %xmm0
xorl %r13d, %r13d
cmpq %r13, %rbp
je 0x20a330
movslq (%rax,%r13,4), %rdx
shlq $0x4, %rdx
movups (%r12,%rdx), %xmm1
maxps %xmm1, %xmm0
incq %r13
jmp 0x20a316
movq %r14, %r12
shlq $0x4, %r12
movups %xmm0, (%r9,%r12)
incq %r14
jmp 0x20a2d4
leaq (%r9,%rcx,4), %r9
incl %r10d
jmp 0x20a2bd
movq 0x28(%rsp), %rdx
incq %rdx
jmp 0x20a26f
xorl %eax, %eax
cmpl $0x0, 0xf8(%r15,%rsi)
movl $0x0, %ecx
movl $0x0, %edx
jne 0x20a3a1
movl 0x2c(%r13), %ecx
movl 0x30(%r13), %edx
subl 0x6c(%rsp), %ecx
addl 0xe4(%r15,%rsi), %ecx
addl 0xe8(%r15,%rsi), %ecx
subl 0x70(%rsp), %edx
addl 0xec(%r15,%rsi), %edx
addl 0xf0(%r15,%rsi), %edx
addl 0x98(%rsp), %edx
addl %r14d, %ecx
movl 0x38(%rsp), %esi
shll $0x2, %esi
movslq %esi, %rsi
movq %rsi, 0xb0(%rsp)
movslq 0x20(%rsp), %rsi
movq %rsi, 0x98(%rsp)
movq 0x10(%rsp), %r12
testl %r12d, %r12d
cmovlel %eax, %r12d
movq %r12, 0x10(%rsp)
movss 0x1bb451(%rip), %xmm0 # 0x3c5834
xorl %esi, %esi
cmpq 0x10(%rsp), %rsi
je 0x20a5f5
movslq 0x6c(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x50(%rsp), %rbp
movq 0x18(%rsp), %rax
movq 0x40(%rax), %r8
imulq %rsi, %r8
imulq 0x10(%rax), %r8
addq (%rax), %r8
movq %r8, 0x20(%rsp)
movq (%r15), %rax
movq %rax, 0x38(%rsp)
movq %rbp, 0xc0(%rsp)
movq %rdi, 0xd0(%rsp)
imulq %rdi, %rbp
movq 0x80(%rsp), %rax
movq %rsi, 0xa8(%rsp)
imulq %rsi, %rax
movq %rax, 0xb8(%rsp)
xorl %esi, %esi
cmpl 0x90(%rsp), %esi
jg 0x20a5e5
movq 0x38(%rsp), %rax
movq -0x18(%rax), %rax
movl 0xe0(%r15,%rax), %eax
movl %esi, 0xa4(%rsp)
imull %esi, %eax
movslq %eax, %rsi
movq 0xd0(%rsp), %rax
imulq %rsi, %rax
addq 0xb8(%rsp), %rax
imulq 0xc0(%rsp), %rax
addq 0xc8(%rsp), %rax
movq %rax, 0xd8(%rsp)
xorl %r9d, %r9d
cmpq 0x98(%rsp), %r9
jg 0x20a5c1
movq 0x38(%rsp), %rax
movq -0x18(%rax), %r11
movl 0xd8(%r15,%r11), %r8d
xorl %r12d, %r12d
testl %r8d, %r8d
cmovlel %r12d, %r8d
movl 0xdc(%r15,%r11), %eax
movq %r9, 0x28(%rsp)
imull %r9d, %eax
movslq %eax, %r9
movq %r9, %rbx
shlq $0x4, %rbx
addq 0xd8(%rsp), %rbx
xorps %xmm1, %xmm1
xorl %r13d, %r13d
cmpq %r8, %r12
je 0x20a591
leaq (%r12,%rsi), %rax
movslq 0xec(%r15,%r11), %rdi
cmpq %rdi, %rax
jge 0x20a52a
incq %r12
addq %rbp, %rbx
jmp 0x20a508
movl %edx, %edi
subl 0xf0(%r15,%r11), %edi
movslq %edi, %rdi
cmpq %rdi, %rax
jge 0x20a591
movl 0xd4(%r15,%r11), %r14d
testl %r14d, %r14d
movl $0x0, %eax
cmovlel %eax, %r14d
shlq $0x4, %r14
movq %r9, %rdi
xorl %eax, %eax
cmpq %rax, %r14
je 0x20a522
movslq 0xe4(%r15,%r11), %r10
cmpq %r10, %rdi
jl 0x20a588
movl %ecx, %r10d
subl 0xe8(%r15,%r11), %r10d
movslq %r10d, %r10
cmpq %r10, %rdi
jge 0x20a522
movups (%rbx,%rax), %xmm2
addps %xmm2, %xmm1
incl %r13d
addq $0x10, %rax
incq %rdi
jmp 0x20a559
cvtsi2ss %r13d, %xmm2
movaps %xmm0, %xmm3
divss %xmm2, %xmm3
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
mulps %xmm1, %xmm3
movq 0x28(%rsp), %r9
movq %r9, %rax
shlq $0x4, %rax
movq 0x20(%rsp), %rdi
movups %xmm3, (%rdi,%rax)
incq %r9
jmp 0x20a4b6
movq 0xb0(%rsp), %rax
movq 0x20(%rsp), %rsi
leaq (%rsi,%rax,4), %rsi
movq %rsi, 0x20(%rsp)
movl 0xa4(%rsp), %esi
incl %esi
jmp 0x20a45b
movq 0xa8(%rsp), %rsi
incq %rsi
jmp 0x20a3e5
leaq 0xe0(%rsp), %rdi
callq 0x6d4aa
xorl %eax, %eax
movq 0x48(%rsp), %rcx
testq %rcx, %rcx
je 0x20a63b
lock
decl (%rcx)
jne 0x20a63b
movq %rax, %rbx
movq 0x40(%rsp), %rsi
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x20a630
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
jmp 0x20a63b
movq %rsi, %rdi
callq 0x573d0
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20a653
jmp 0x20a68c
jmp 0x20a653
movq %rax, %rbx
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x20a684
lock
decl (%rax)
jne 0x20a684
movq 0x40(%rsp), %rsi
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
jne 0x20a67e
movq %rsi, %rdi
callq 0x573d0
jmp 0x20a684
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x57330
movq %rax, %rdi
callq 0x582a4
| /ysh329[P]ncnn/src/layer/x86/pooling_x86.cpp |
ncnn::PReLU_x86_avx512::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int PReLU_x86_avx512::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
int dims = bottom_top_blob.dims;
int w = bottom_top_blob.w;
int h = bottom_top_blob.h;
int channels = bottom_top_blob.c;
int elempack = bottom_top_blob.elempack;
if (dims == 1)
{
const int size = w * elempack;
if (num_slope > 1)
{
float* ptr = bottom_top_blob;
const float* slope = slope_data;
int nn_size = 0;
int remain_size_start = 0;
#if __SSE2__
#if __AVX__
#if __AVX512F__
nn_size = (size - remain_size_start) / 16;
#pragma omp parallel for num_threads(opt.num_threads)
for (int ii = 0; ii < nn_size; ii++)
{
int i = remain_size_start + ii * 16;
__m512 _p512 = _mm512_loadu_ps(ptr + i);
__m512 _slope512 = _mm512_loadu_ps(slope + i);
_mm512_storeu_ps(ptr + i, prelu_avx512(_p512, _slope512));
}
remain_size_start += nn_size * 16;
#endif // __AVX512F__
nn_size = (size - remain_size_start) / 8;
#pragma omp parallel for num_threads(opt.num_threads)
for (int ii = 0; ii < nn_size; ii++)
{
int i = remain_size_start + ii * 8;
__m256 _p256 = _mm256_loadu_ps(ptr + i);
__m256 _slope256 = _mm256_loadu_ps(slope + i);
_mm256_storeu_ps(ptr + i, prelu_avx(_p256, _slope256));
}
remain_size_start += nn_size * 8;
#endif // __AVX__
nn_size = (size - remain_size_start) / 4;
#pragma omp parallel for num_threads(opt.num_threads)
for (int ii = 0; ii < nn_size; ii++)
{
int i = remain_size_start + ii * 4;
__m128 _p128 = _mm_load_ps(ptr + i);
__m128 _slope128 = _mm_load_ps(slope + i);
_mm_store_ps(ptr + i, prelu_sse(_p128, _slope128));
}
remain_size_start += nn_size * 4;
#endif // __SSE2__
#pragma omp parallel for num_threads(opt.num_threads)
for (int i = remain_size_start; i < size; i++)
{
if (ptr[i] < 0)
ptr[i] *= slope_data[i];
}
}
else
{
float* ptr = bottom_top_blob;
const float slope = slope_data[0];
int nn_size = 0;
int remain_size_start = 0;
#if __SSE2__
#if __AVX__
#if __AVX512F__
nn_size = (size - remain_size_start) / 16;
#pragma omp parallel for num_threads(opt.num_threads)
for (int ii = 0; ii < nn_size; ii++)
{
int i = remain_size_start + ii * 16;
__m512 _p512 = _mm512_loadu_ps(ptr + i);
__m512 _slope512 = _mm512_set1_ps(slope);
_mm512_storeu_ps(ptr + i, prelu_avx512(_p512, _slope512));
}
remain_size_start += nn_size * 16;
#endif // __AVX512F__
nn_size = (size - remain_size_start) / 8;
#pragma omp parallel for num_threads(opt.num_threads)
for (int ii = 0; ii < nn_size; ii++)
{
int i = remain_size_start + ii * 8;
__m256 _p256 = _mm256_loadu_ps(ptr + i);
__m256 _slope256 = _mm256_set1_ps(slope);
_mm256_storeu_ps(ptr + i, prelu_avx(_p256, _slope256));
}
remain_size_start += nn_size * 8;
#endif // __AVX__
nn_size = (size - remain_size_start) / 4;
#pragma omp parallel for num_threads(opt.num_threads)
for (int ii = 0; ii < nn_size; ii++)
{
int i = remain_size_start + ii * 4;
__m128 _p128 = _mm_load_ps(ptr + i);
__m128 _slope128 = _mm_set1_ps(slope);
_mm_store_ps(ptr + i, prelu_sse(_p128, _slope128));
}
remain_size_start += nn_size * 4;
#endif // __SSE2__
#pragma omp parallel for num_threads(opt.num_threads)
for (int i = remain_size_start; i < size; i++)
{
if (ptr[i] < 0)
ptr[i] *= slope;
}
}
}
if (dims == 2)
{
const int size = w * elempack;
#pragma omp parallel for num_threads(opt.num_threads)
for (int i = 0; i < h; i++)
{
float* ptr = bottom_top_blob.row(i);
int j = 0;
float slope = num_slope > 1 ? slope_data[i] : slope_data[0];
#if __SSE2__
__m128 _slope128 = num_slope > 1 && (elempack == 4) ? _mm_load_ps((const float*)slope_data + i * 4) : _mm_set1_ps(slope);
#if __AVX__
__m256 _slope256 = num_slope > 1 && (elempack == 8) ? _mm256_loadu_ps((const float*)slope_data + i * 8) : _mm256_insertf128_ps(_mm256_castps128_ps256(_slope128), _slope128, 1);
#if __AVX512F__
__m512 _slope512 = num_slope > 1 && (elempack == 16) ? _mm512_loadu_ps((const float*)slope_data + i * 16) : _mm512_insertf32x8(_mm512_castps256_ps512(_slope256), _slope256, 1);
for (; j + 15 < size; j += 16)
{
__m512 _p512 = _mm512_loadu_ps(ptr);
_mm512_storeu_ps(ptr, prelu_avx512(_p512, _slope512));
ptr += 16;
}
#endif // __AVX512F__
for (; j + 7 < size; j += 8)
{
__m256 _p256 = _mm256_loadu_ps(ptr);
_mm256_storeu_ps(ptr, prelu_avx(_p256, _slope256));
ptr += 8;
}
#endif // __AVX__
for (; j + 3 < size; j += 4)
{
__m128 _p128 = _mm_loadu_ps(ptr);
_mm_storeu_ps(ptr, prelu_sse(_p128, _slope128));
ptr += 4;
}
#endif // __SSE2__
for (; j < size; j++)
{
if (*ptr < 0)
*ptr *= slope;
ptr++;
}
}
}
if (dims == 3)
{
const int size = w * h * elempack;
#pragma omp parallel for num_threads(opt.num_threads)
for (int q = 0; q < channels; q++)
{
float* ptr = bottom_top_blob.channel(q);
int i = 0;
float slope = num_slope > 1 ? slope_data[q] : slope_data[0];
#if __SSE2__
__m128 _slope128 = num_slope > 1 && (elempack == 4) ? _mm_load_ps((const float*)slope_data + q * 4) : _mm_set1_ps(slope);
#if __AVX__
__m256 _slope256 = num_slope > 1 && (elempack == 8) ? _mm256_loadu_ps((const float*)slope_data + q * 8) : _mm256_insertf128_ps(_mm256_castps128_ps256(_slope128), _slope128, 1);
#if __AVX512F__
__m512 _slope512 = num_slope > 1 && (elempack == 16) ? _mm512_loadu_ps((const float*)slope_data + q * 16) : _mm512_insertf32x8(_mm512_castps256_ps512(_slope256), _slope256, 1);
for (; i + 15 < size; i += 16)
{
__m512 _p512 = _mm512_loadu_ps(ptr);
_mm512_storeu_ps(ptr, prelu_avx512(_p512, _slope512));
ptr += 16;
}
#endif // __AVX512F__
for (; i + 7 < size; i += 8)
{
__m256 _p256 = _mm256_loadu_ps(ptr);
_mm256_storeu_ps(ptr, prelu_avx(_p256, _slope256));
ptr += 8;
}
#endif // __AVX__
for (; i + 3 < size; i += 4)
{
__m128 _p128 = _mm_load_ps(ptr);
_mm_store_ps(ptr, prelu_sse(_p128, _slope128));
ptr += 4;
}
#endif // __SSE2__
for (; i < size; i++)
{
if (*ptr < 0)
*ptr *= slope;
ptr++;
}
}
}
return 0;
} | pushq %r14
pushq %rbx
movl 0x18(%rsi), %ecx
movl 0x28(%rsi), %r8d
movl 0x2c(%rsi), %eax
movl 0x30(%rsi), %edx
cmpl $0x3, %r8d
je 0x210e66
cmpl $0x2, %r8d
je 0x210cf9
cmpl $0x1, %r8d
jne 0x2111e1
imull %eax, %ecx
movq (%rdi), %r9
movq -0x18(%r9), %rax
cmpl $0x2, 0xd0(%rdi,%rax)
movq (%rsi), %r8
movq 0xd8(%rdi,%rax), %r10
jl 0x210fdb
movl $0x10, %esi
movl %ecx, %eax
cltd
idivl %esi
movl %eax, %esi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
shlq $0x6, %rdx
vxorps %xmm0, %xmm0, %xmm0
cmpq %rax, %rdx
je 0x21102c
vmovups (%r8,%rax), %zmm1
vmaxps %zmm0, %zmm1, %zmm2
vminps %zmm0, %zmm1, %zmm1
vfmadd132ps (%r10,%rax), %zmm2, %zmm1 # zmm1 = (zmm1 * mem) + zmm2
vmovups %zmm1, (%r8,%rax)
addq $0x40, %rax
jmp 0x210cc9
imull %ecx, %eax
movq (%rdi), %r8
xorl %r9d, %r9d
testl %edx, %edx
cmovlel %r9d, %edx
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm2, %xmm2, %xmm2
vxorps %xmm3, %xmm3, %xmm3
cmpq %rdx, %r9
je 0x2111e1
movq -0x18(%r8), %r10
cmpl $0x1, 0xd0(%rdi,%r10)
movq 0xd8(%rdi,%r10), %r10
jle 0x210d56
vmovss (%r10,%r9,4), %xmm4
cmpl $0x4, %ecx
jne 0x210e29
movq %r9, %r11
shlq $0x4, %r11
vmovaps (%r10,%r11), %xmm5
jmp 0x210d5f
vbroadcastss (%r10), %xmm5
vmovaps %xmm5, %xmm4
vinsertf128 $0x1, %xmm5, %ymm5, %ymm6
vinsertf64x4 $0x1, %ymm6, %zmm6, %zmm7
movslq 0x2c(%rsi), %r10
imulq %r9, %r10
imulq 0x10(%rsi), %r10
addq (%rsi), %r10
xorl %r11d, %r11d
leal 0xf(%r11), %ebx
cmpl %eax, %ebx
jge 0x210dce
vmovups (%r10), %zmm8
vmaxps %zmm0, %zmm8, %zmm9
vminps %zmm0, %zmm8, %zmm8
vfmadd213ps %zmm9, %zmm7, %zmm8 # zmm8 = (zmm7 * zmm8) + zmm9
vmovups %zmm8, (%r10)
addq $0x40, %r10
addl $0x10, %r11d
jmp 0x210d7f
vmovups (%r10), %ymm7
vmaxps %ymm1, %ymm7, %ymm8
vminps %ymm1, %ymm7, %ymm7
vfmadd213ps %ymm8, %ymm6, %ymm7 # ymm7 = (ymm6 * ymm7) + ymm8
vmovups %ymm7, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jl 0x210daf
jmp 0x210df7
vmovups (%r10), %xmm6
vmaxps %xmm2, %xmm6, %xmm7
vminps %xmm2, %xmm6, %xmm6
vfmadd213ps %xmm7, %xmm5, %xmm6 # xmm6 = (xmm5 * xmm6) + xmm7
vmovups %xmm6, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x210dd8
jmp 0x210e1c
vmovss (%r10), %xmm5
vucomiss %xmm5, %xmm3
jbe 0x210e15
vmulss %xmm4, %xmm5, %xmm5
vmovss %xmm5, (%r10)
addq $0x4, %r10
incl %r11d
cmpl %eax, %r11d
jl 0x210e01
incq %r9
jmp 0x210d18
vbroadcastss %xmm4, %xmm5
cmpl $0x8, %ecx
jne 0x210e45
movq %r9, %r11
shlq $0x5, %r11
vmovups (%r10,%r11), %ymm6
jmp 0x210d65
vbroadcastss %xmm5, %ymm6
cmpl $0x10, %ecx
jne 0x210d65
movq %r9, %r11
shlq $0x6, %r11
vmovups (%r10,%r11), %zmm7
jmp 0x210d6c
movl 0x38(%rsi), %r8d
imull %ecx, %eax
imull %edx, %eax
movq (%rdi), %rdx
xorl %r9d, %r9d
testl %r8d, %r8d
cmovlel %r9d, %r8d
vxorps %xmm0, %xmm0, %xmm0
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm2, %xmm2, %xmm2
vxorps %xmm3, %xmm3, %xmm3
cmpq %r8, %r9
je 0x2111e1
movq -0x18(%rdx), %r10
cmpl $0x1, 0xd0(%rdi,%r10)
movq 0xd8(%rdi,%r10), %r10
jle 0x210ecb
vmovss (%r10,%r9,4), %xmm4
cmpl $0x4, %ecx
jne 0x210f9e
movq %r9, %r11
shlq $0x4, %r11
vmovaps (%r10,%r11), %xmm5
jmp 0x210ed4
vbroadcastss (%r10), %xmm5
vmovaps %xmm5, %xmm4
vinsertf128 $0x1, %xmm5, %ymm5, %ymm6
vinsertf64x4 $0x1, %ymm6, %zmm6, %zmm7
movq 0x40(%rsi), %r10
imulq %r9, %r10
imulq 0x10(%rsi), %r10
addq (%rsi), %r10
xorl %r11d, %r11d
leal 0xf(%r11), %ebx
cmpl %eax, %ebx
jge 0x210f43
vmovups (%r10), %zmm8
vmaxps %zmm0, %zmm8, %zmm9
vminps %zmm0, %zmm8, %zmm8
vfmadd213ps %zmm9, %zmm7, %zmm8 # zmm8 = (zmm7 * zmm8) + zmm9
vmovups %zmm8, (%r10)
addq $0x40, %r10
addl $0x10, %r11d
jmp 0x210ef4
vmovups (%r10), %ymm7
vmaxps %ymm1, %ymm7, %ymm8
vminps %ymm1, %ymm7, %ymm7
vfmadd213ps %ymm8, %ymm6, %ymm7 # ymm7 = (ymm6 * ymm7) + ymm8
vmovups %ymm7, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jl 0x210f24
jmp 0x210f6c
vmovaps (%r10), %xmm6
vmaxps %xmm2, %xmm6, %xmm7
vminps %xmm2, %xmm6, %xmm6
vfmadd213ps %xmm7, %xmm5, %xmm6 # xmm6 = (xmm5 * xmm6) + xmm7
vmovaps %xmm6, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x210f4d
jmp 0x210f91
vmovss (%r10), %xmm5
vucomiss %xmm5, %xmm3
jbe 0x210f8a
vmulss %xmm4, %xmm5, %xmm5
vmovss %xmm5, (%r10)
addq $0x4, %r10
incl %r11d
cmpl %eax, %r11d
jl 0x210f76
incq %r9
jmp 0x210e8d
vbroadcastss %xmm4, %xmm5
cmpl $0x8, %ecx
jne 0x210fba
movq %r9, %r11
shlq $0x5, %r11
vmovups (%r10,%r11), %ymm6
jmp 0x210eda
vbroadcastss %xmm5, %ymm6
cmpl $0x10, %ecx
jne 0x210eda
movq %r9, %r11
shlq $0x6, %r11
vmovups (%r10,%r11), %zmm7
jmp 0x210ee1
vbroadcastss (%r10), %zmm0
movl $0x10, %esi
movl %ecx, %eax
cltd
idivl %esi
movl %eax, %esi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %edx
cmovgl %esi, %edx
shlq $0x6, %rdx
vxorps %xmm1, %xmm1, %xmm1
cmpq %rax, %rdx
je 0x211081
vmovups (%r8,%rax), %zmm2
vmaxps %zmm1, %zmm2, %zmm3
vminps %zmm1, %zmm2, %zmm2
vfmadd213ps %zmm3, %zmm0, %zmm2 # zmm2 = (zmm0 * zmm2) + zmm3
vmovups %zmm2, (%r8,%rax)
addq $0x40, %rax
jmp 0x211001
shll $0x4, %esi
movl %ecx, %eax
subl %esi, %eax
movl $0x8, %r11d
cltd
idivl %r11d
movslq %esi, %r14
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %r11d
cmovgl %eax, %r11d
shlq $0x5, %r11
leaq (%r8,%r14,4), %rbx
leaq (%r10,%r14,4), %r14
vxorps %xmm0, %xmm0, %xmm0
cmpq %rdx, %r11
je 0x2110d4
vmovups (%rbx,%rdx), %ymm1
vmaxps %ymm0, %ymm1, %ymm2
vminps %ymm0, %ymm1, %ymm1
vfmadd132ps (%r14,%rdx), %ymm2, %ymm1 # ymm1 = (ymm1 * mem) + ymm2
vmovups %ymm1, (%rbx,%rdx)
addq $0x20, %rdx
jmp 0x21105e
shll $0x4, %esi
movl %ecx, %eax
subl %esi, %eax
movl $0x8, %edi
cltd
idivl %edi
vbroadcastss %xmm0, %ymm1
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %edi
cmovgl %eax, %edi
movslq %esi, %r9
leaq (%r8,%r9,4), %r9
shlq $0x5, %rdi
vxorps %xmm2, %xmm2, %xmm2
cmpq %rdx, %rdi
je 0x211129
vmovups (%r9,%rdx), %ymm3
vmaxps %ymm2, %ymm3, %ymm4
vminps %ymm2, %ymm3, %ymm3
vfmadd213ps %ymm4, %ymm1, %ymm3 # ymm3 = (ymm1 * ymm3) + ymm4
vmovups %ymm3, (%r9,%rdx)
addq $0x20, %rdx
jmp 0x2110b0
leal (%rsi,%rax,8), %esi
movl %ecx, %eax
subl %esi, %eax
movl $0x4, %r11d
cltd
idivl %r11d
movslq %esi, %r14
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %r11d
cmovgl %eax, %r11d
shlq $0x4, %r11
leaq (%r8,%r14,4), %rbx
leaq (%r10,%r14,4), %r10
vxorps %xmm0, %xmm0, %xmm0
cmpq %rdx, %r11
je 0x21117c
vmovaps (%rbx,%rdx), %xmm1
vmaxps %xmm0, %xmm1, %xmm2
vminps %xmm0, %xmm1, %xmm1
vfmadd132ps (%r10,%rdx), %xmm2, %xmm1 # xmm1 = (xmm1 * mem) + xmm2
vmovaps %xmm1, (%rbx,%rdx)
addq $0x10, %rdx
jmp 0x211106
leal (%rsi,%rax,8), %esi
movl %ecx, %eax
subl %esi, %eax
movl $0x4, %edi
cltd
idivl %edi
vbroadcastss %xmm0, %xmm1
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %edi
cmovgl %eax, %edi
movslq %esi, %r9
leaq (%r8,%r9,4), %r9
shlq $0x4, %rdi
vxorps %xmm2, %xmm2, %xmm2
cmpq %rdx, %rdi
je 0x2111b5
vmovaps (%r9,%rdx), %xmm3
vmaxps %xmm2, %xmm3, %xmm4
vminps %xmm2, %xmm3, %xmm3
vfmadd213ps %xmm4, %xmm1, %xmm3 # xmm3 = (xmm1 * xmm3) + xmm4
vmovaps %xmm3, (%r9,%rdx)
addq $0x10, %rdx
jmp 0x211158
leal (%rsi,%rax,4), %eax
cltq
movslq %ecx, %rcx
vxorps %xmm0, %xmm0, %xmm0
cmpq %rcx, %rax
jge 0x2111e1
vmovss (%r8,%rax,4), %xmm1
vucomiss %xmm1, %xmm0
jbe 0x2111b0
movq -0x18(%r9), %rdx
movq 0xd8(%rdi,%rdx), %rdx
vmulss (%rdx,%rax,4), %xmm1, %xmm1
vmovss %xmm1, (%r8,%rax,4)
incq %rax
jmp 0x211188
leal (%rsi,%rax,4), %eax
cltq
movslq %ecx, %rcx
vxorps %xmm1, %xmm1, %xmm1
cmpq %rcx, %rax
jge 0x2111e1
vmovss (%r8,%rax,4), %xmm2
vucomiss %xmm2, %xmm1
jbe 0x2111dc
vmulss %xmm0, %xmm2, %xmm2
vmovss %xmm2, (%r8,%rax,4)
incq %rax
jmp 0x2111c1
xorl %eax, %eax
popq %rbx
popq %r14
vzeroupper
retq
| /ysh329[P]ncnn/build_O2/src/layer/x86/prelu_x86_avx512.cpp |
ncnn::BinaryOp_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BinaryOp_x86_fma::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace BinaryOp_x86_fma_functor;
if (op_type == Operation_ADD)
return binary_op_scalar_inplace<binary_op_add>(bottom_top_blob, b, opt);
if (op_type == Operation_SUB)
return binary_op_scalar_inplace<binary_op_sub>(bottom_top_blob, b, opt);
if (op_type == Operation_MUL)
return binary_op_scalar_inplace<binary_op_mul>(bottom_top_blob, b, opt);
if (op_type == Operation_DIV)
return binary_op_scalar_inplace<binary_op_div>(bottom_top_blob, b, opt);
if (op_type == Operation_MAX)
return binary_op_scalar_inplace<binary_op_max>(bottom_top_blob, b, opt);
if (op_type == Operation_MIN)
return binary_op_scalar_inplace<binary_op_min>(bottom_top_blob, b, opt);
if (op_type == Operation_POW)
return binary_op_scalar_inplace<binary_op_pow>(bottom_top_blob, b, opt);
if (op_type == Operation_RSUB)
return binary_op_scalar_inplace<binary_op_rsub>(bottom_top_blob, b, opt);
if (op_type == Operation_RDIV)
return binary_op_scalar_inplace<binary_op_rdiv>(bottom_top_blob, b, opt);
return 0;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xe0, %rsp
movq (%rdi), %rax
movq -0x18(%rax), %rdx
movl 0xd0(%rdi,%rdx), %eax
cmpq $0x8, %rax
ja 0x2a9b9c
movq %rsi, %r14
leaq 0x122d22(%rip), %rcx # 0x3cc188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
vbroadcastss 0xd8(%rdi,%rdx), %ymm0
movl 0x30(%r14), %eax
movl 0x38(%r14), %ecx
imull 0x2c(%r14), %eax
imull 0x34(%r14), %eax
imull 0x18(%r14), %eax
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2a9b9c
movq (%r14), %rsi
movq 0x10(%r14), %r9
movq 0x40(%r14), %r8
movq %r8, %r10
imulq %rdx, %r10
imulq %r9, %r10
addq %rsi, %r10
xorl %edi, %edi
xorl %r11d, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jge 0x2a94f4
vaddps (%r10), %ymm0, %ymm1
vmovups %ymm1, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
addq $0x8, %rdi
jmp 0x2a94be
vaddps (%r10), %xmm0, %xmm1
vmovaps %xmm1, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
addq $0x4, %rdi
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x2a94de
imulq %r9, %r8
imulq %rdx, %r8
addq %r8, %rsi
cmpl %eax, %edi
jge 0x2a951a
vaddss (%rsi,%rdi,4), %xmm0, %xmm1
vmovss %xmm1, (%rsi,%rdi,4)
incq %rdi
jmp 0x2a9507
incq %rdx
jmp 0x2a9497
vbroadcastss 0xd8(%rdi,%rdx), %ymm0
movl 0x30(%r14), %eax
movl 0x38(%r14), %ecx
imull 0x2c(%r14), %eax
imull 0x34(%r14), %eax
imull 0x18(%r14), %eax
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2a9b9c
movq (%r14), %rsi
movq 0x10(%r14), %r9
movq 0x40(%r14), %r8
movq %r8, %r10
imulq %rdx, %r10
imulq %r9, %r10
addq %rsi, %r10
xorl %edi, %edi
xorl %r11d, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jge 0x2a95a7
vmaxps (%r10), %ymm0, %ymm1
vmovups %ymm1, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
addq $0x8, %rdi
jmp 0x2a9571
vmaxps (%r10), %xmm0, %xmm1
vmovaps %xmm1, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
addq $0x4, %rdi
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x2a9591
imulq %r9, %r8
imulq %rdx, %r8
addq %r8, %rsi
cmpl %eax, %edi
jge 0x2a95cd
vmaxss (%rsi,%rdi,4), %xmm0, %xmm1
vmovss %xmm1, (%rsi,%rdi,4)
incq %rdi
jmp 0x2a95ba
incq %rdx
jmp 0x2a954a
vbroadcastss 0xd8(%rdi,%rdx), %ymm0
movl 0x30(%r14), %eax
movl 0x38(%r14), %ecx
imull 0x2c(%r14), %eax
imull 0x34(%r14), %eax
imull 0x18(%r14), %eax
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2a9b9c
movq (%r14), %rsi
movq 0x10(%r14), %r9
movq 0x40(%r14), %r8
movq %r8, %r10
imulq %rdx, %r10
imulq %r9, %r10
addq %rsi, %r10
xorl %edi, %edi
xorl %r11d, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jge 0x2a965a
vmulps (%r10), %ymm0, %ymm1
vmovups %ymm1, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
addq $0x8, %rdi
jmp 0x2a9624
vmulps (%r10), %xmm0, %xmm1
vmovaps %xmm1, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
addq $0x4, %rdi
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x2a9644
imulq %r9, %r8
imulq %rdx, %r8
addq %r8, %rsi
cmpl %eax, %edi
jge 0x2a9680
vmulss (%rsi,%rdi,4), %xmm0, %xmm1
vmovss %xmm1, (%rsi,%rdi,4)
incq %rdi
jmp 0x2a966d
incq %rdx
jmp 0x2a95fd
movl 0x30(%r14), %eax
imull 0x2c(%r14), %eax
imull 0x34(%r14), %eax
movl 0x38(%r14), %ecx
imull 0x18(%r14), %eax
vmovss 0x11c18d(%rip), %xmm0 # 0x3c5834
vdivss 0xd8(%rdi,%rdx), %xmm0, %xmm0
vshufps $0x0, %xmm0, %xmm0, %xmm1 # xmm1 = xmm0[0,0,0,0]
vinsertf128 $0x1, %xmm1, %ymm1, %ymm2
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2a9b9c
movq (%r14), %rsi
movq 0x10(%r14), %r9
movq 0x40(%r14), %r8
movq %r8, %r10
imulq %rdx, %r10
imulq %r9, %r10
addq %rsi, %r10
xorl %edi, %edi
xorl %r11d, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jge 0x2a971f
vmulps (%r10), %ymm2, %ymm3
vmovups %ymm3, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
addq $0x8, %rdi
jmp 0x2a96e9
vmulps (%r10), %xmm1, %xmm3
vmovaps %xmm3, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
addq $0x4, %rdi
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x2a9709
imulq %r9, %r8
imulq %rdx, %r8
addq %r8, %rsi
cmpl %eax, %edi
jge 0x2a9745
vmulss (%rsi,%rdi,4), %xmm0, %xmm3
vmovss %xmm3, (%rsi,%rdi,4)
incq %rdi
jmp 0x2a9732
incq %rdx
jmp 0x2a96c2
vbroadcastss 0xd8(%rdi,%rdx), %ymm0
movl 0x30(%r14), %eax
movl 0x38(%r14), %ecx
imull 0x2c(%r14), %eax
imull 0x34(%r14), %eax
imull 0x18(%r14), %eax
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2a9b9c
movq (%r14), %rsi
movq 0x10(%r14), %r9
movq 0x40(%r14), %r8
movq %r8, %r10
imulq %rdx, %r10
imulq %r9, %r10
addq %rsi, %r10
xorl %edi, %edi
xorl %r11d, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jge 0x2a97d2
vsubps (%r10), %ymm0, %ymm1
vmovups %ymm1, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
addq $0x8, %rdi
jmp 0x2a979c
vsubps (%r10), %xmm0, %xmm1
vmovaps %xmm1, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
addq $0x4, %rdi
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x2a97bc
imulq %r9, %r8
imulq %rdx, %r8
addq %r8, %rsi
cmpl %eax, %edi
jge 0x2a97f8
vsubss (%rsi,%rdi,4), %xmm0, %xmm1
vmovss %xmm1, (%rsi,%rdi,4)
incq %rdi
jmp 0x2a97e5
incq %rdx
jmp 0x2a9775
vbroadcastss 0xd8(%rdi,%rdx), %ymm0
movl 0x30(%r14), %eax
movl 0x38(%r14), %ecx
imull 0x2c(%r14), %eax
imull 0x34(%r14), %eax
imull 0x18(%r14), %eax
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2a9b9c
movq (%r14), %rsi
movq 0x10(%r14), %r9
movq 0x40(%r14), %r8
movq %r8, %r10
imulq %rdx, %r10
imulq %r9, %r10
addq %rsi, %r10
xorl %edi, %edi
xorl %r11d, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jge 0x2a988d
vmovups (%r10), %ymm1
vsubps %ymm0, %ymm1, %ymm1
vmovups %ymm1, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
addq $0x8, %rdi
jmp 0x2a984f
vmovaps (%r10), %xmm1
vsubps %xmm0, %xmm1, %xmm1
vmovaps %xmm1, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
addq $0x4, %rdi
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x2a9873
imulq %r9, %r8
imulq %rdx, %r8
addq %r8, %rsi
cmpl %eax, %edi
jge 0x2a98b7
vmovss (%rsi,%rdi,4), %xmm1
vsubss %xmm0, %xmm1, %xmm1
vmovss %xmm1, (%rsi,%rdi,4)
incq %rdi
jmp 0x2a98a0
incq %rdx
jmp 0x2a9828
vbroadcastss 0xd8(%rdi,%rdx), %ymm0
movl 0x30(%r14), %eax
movl 0x38(%r14), %ecx
imull 0x2c(%r14), %eax
imull 0x34(%r14), %eax
imull 0x18(%r14), %eax
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2a9b9c
movq (%r14), %rsi
movq 0x10(%r14), %r9
movq 0x40(%r14), %r8
movq %r8, %r10
imulq %rdx, %r10
imulq %r9, %r10
addq %rsi, %r10
xorl %edi, %edi
xorl %r11d, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jge 0x2a9944
vminps (%r10), %ymm0, %ymm1
vmovups %ymm1, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
addq $0x8, %rdi
jmp 0x2a990e
vminps (%r10), %xmm0, %xmm1
vmovaps %xmm1, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
addq $0x4, %rdi
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x2a992e
imulq %r9, %r8
imulq %rdx, %r8
addq %r8, %rsi
cmpl %eax, %edi
jge 0x2a996a
vminss (%rsi,%rdi,4), %xmm0, %xmm1
vmovss %xmm1, (%rsi,%rdi,4)
incq %rdi
jmp 0x2a9957
incq %rdx
jmp 0x2a98e7
vbroadcastss 0xd8(%rdi,%rdx), %ymm0
vmovaps %ymm0, 0x40(%rsp)
movl 0x30(%r14), %ebx
movl 0x38(%r14), %eax
imull 0x2c(%r14), %ebx
imull 0x34(%r14), %ebx
imull 0x18(%r14), %ebx
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
movq %rax, 0x20(%rsp)
movq %r14, 0x18(%rsp)
cmpq 0x20(%rsp), %r15
je 0x2a9b9c
movq (%r14), %r12
movq 0x10(%r14), %rax
movq 0x40(%r14), %r14
movq %r14, 0x30(%rsp)
movq %r15, 0x38(%rsp)
imulq %r15, %r14
movq %rax, 0x28(%rsp)
imulq %rax, %r14
addq %r12, %r14
vmovaps 0x40(%rsp), %ymm0
vmovaps %ymm0, 0xa0(%rsp)
xorl %r13d, %r13d
xorl %r15d, %r15d
leal 0x7(%r15), %eax
cmpl %ebx, %eax
jge 0x2a9a2e
vmovups (%r14), %ymm0
vmovaps %ymm0, 0x60(%rsp)
leaq 0x17(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
callq 0x2ab90e
vmovups %ymm0, (%r14)
addq $0x20, %r14
addl $0x8, %r15d
addq $0x8, %r13
jmp 0x2a99f1
vmovaps 0x40(%rsp), %ymm0
vmovaps %xmm0, 0x60(%rsp)
leal 0x3(%r15), %eax
cmpl %ebx, %eax
jge 0x2a9a7d
vmovaps (%r14), %xmm0
vmovaps %xmm0, 0x90(%rsp)
leaq 0x17(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x60(%rsp), %rdx
vzeroupper
callq 0x2abb1e
vmovaps %xmm0, (%r14)
addq $0x10, %r14
addl $0x4, %r15d
addq $0x4, %r13
jmp 0x2a9a3a
movq 0x30(%rsp), %rax
imulq 0x28(%rsp), %rax
movq 0x38(%rsp), %r15
imulq %r15, %rax
addq %rax, %r12
movq 0x18(%rsp), %r14
cmpl %ebx, %r13d
jge 0x2a9abd
vmovss (%r12,%r13,4), %xmm0
vmovaps 0x40(%rsp), %ymm1
vzeroupper
callq 0x570e0
vmovss %xmm0, (%r12,%r13,4)
incq %r13
jmp 0x2a9a99
incq %r15
jmp 0x2a99ac
vbroadcastss 0xd8(%rdi,%rdx), %ymm0
movl 0x30(%r14), %eax
movl 0x38(%r14), %ecx
imull 0x2c(%r14), %eax
imull 0x34(%r14), %eax
imull 0x18(%r14), %eax
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rcx, %rdx
je 0x2a9b9c
movq (%r14), %rsi
movq 0x10(%r14), %r9
movq 0x40(%r14), %r8
movq %r8, %r10
imulq %rdx, %r10
imulq %r9, %r10
addq %rsi, %r10
xorl %edi, %edi
xorl %r11d, %r11d
leal 0x7(%r11), %ebx
cmpl %eax, %ebx
jge 0x2a9b6e
vmovups (%r10), %ymm1
vrcpps %ymm1, %ymm2
vmulps %ymm2, %ymm0, %ymm3
vfmsub213ps %ymm0, %ymm3, %ymm1 # ymm1 = (ymm3 * ymm1) - ymm0
vfnmadd213ps %ymm3, %ymm2, %ymm1 # ymm1 = -(ymm2 * ymm1) + ymm3
vmovups %ymm1, (%r10)
addq $0x20, %r10
addl $0x8, %r11d
addq $0x8, %rdi
jmp 0x2a9b14
vmovaps (%r10), %xmm1
vrcpps %xmm1, %xmm2
vmulps %xmm2, %xmm0, %xmm3
vfmsub213ps %xmm0, %xmm3, %xmm1 # xmm1 = (xmm3 * xmm1) - xmm0
vfnmadd213ps %xmm3, %xmm2, %xmm1 # xmm1 = -(xmm2 * xmm1) + xmm3
vmovaps %xmm1, (%r10)
addq $0x10, %r10
addl $0x4, %r11d
addq $0x4, %rdi
leal 0x3(%r11), %ebx
cmpl %eax, %ebx
jl 0x2a9b46
imulq %r9, %r8
imulq %rdx, %r8
addq %r8, %rsi
cmpl %eax, %edi
jge 0x2a9b94
vdivss (%rsi,%rdi,4), %xmm0, %xmm1
vmovss %xmm1, (%rsi,%rdi,4)
incq %rdi
jmp 0x2a9b81
incq %rdx
jmp 0x2a9aed
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
| /ysh329[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
virtual thunk to ncnn::BinaryOp_x86_fma::forward_inplace(ncnn::Mat&, ncnn::Option const&) const | int BinaryOp_x86_fma::forward_inplace(Mat& bottom_top_blob, const Option& opt) const
{
using namespace BinaryOp_x86_fma_functor;
if (op_type == Operation_ADD)
return binary_op_scalar_inplace<binary_op_add>(bottom_top_blob, b, opt);
if (op_type == Operation_SUB)
return binary_op_scalar_inplace<binary_op_sub>(bottom_top_blob, b, opt);
if (op_type == Operation_MUL)
return binary_op_scalar_inplace<binary_op_mul>(bottom_top_blob, b, opt);
if (op_type == Operation_DIV)
return binary_op_scalar_inplace<binary_op_div>(bottom_top_blob, b, opt);
if (op_type == Operation_MAX)
return binary_op_scalar_inplace<binary_op_max>(bottom_top_blob, b, opt);
if (op_type == Operation_MIN)
return binary_op_scalar_inplace<binary_op_min>(bottom_top_blob, b, opt);
if (op_type == Operation_POW)
return binary_op_scalar_inplace<binary_op_pow>(bottom_top_blob, b, opt);
if (op_type == Operation_RSUB)
return binary_op_scalar_inplace<binary_op_rsub>(bottom_top_blob, b, opt);
if (op_type == Operation_RDIV)
return binary_op_scalar_inplace<binary_op_rdiv>(bottom_top_blob, b, opt);
return 0;
} | pushq %rax
movq (%rdi), %rax
addq -0x58(%rax), %rdi
callq 0x2a942c
xorl %eax, %eax
popq %rcx
retq
| /ysh329[P]ncnn/build_O2/src/layer/x86/binaryop_x86_fma.cpp |
virtual thunk to ncnn::DeformableConv2D_x86_avx::create_pipeline(ncnn::Option const&) | int DeformableConv2D_x86_avx::create_pipeline(const Option& opt)
{
const int in_c = weight_data_size / (num_output * kernel_h * kernel_w);
{
Mat weight_3d = weight_data.reshape(kernel_w * kernel_h, in_c, num_output);
weight_data_t.create(in_c, kernel_w * kernel_h, num_output);
if (weight_data_t.empty())
return -100;
for (int q = 0; q < num_output; q++)
{
const Mat m = weight_3d.channel(q);
float* outptr = weight_data_t.channel(q);
for (int i = 0; i < kernel_w * kernel_h; i++)
{
for (int j = 0; j < in_c; j++)
{
*outptr++ = m.row(j)[i];
}
}
}
weight_3d.release();
weight_data_t = weight_data_t.reshape(in_c * kernel_w * kernel_h, num_output);
inner_product = ncnn::create_layer(ncnn::LayerType::InnerProduct);
ncnn::ParamDict pd;
pd.set(0, num_output);
pd.set(1, bias_term);
pd.set(2, weight_data_size);
pd.set(9, activation_type);
pd.set(10, activation_params);
inner_product->load_param(pd);
ncnn::Mat weights[2];
weights[0] = weight_data_t;
if (bias_term)
weights[1] = bias_data;
inner_product->load_model(ncnn::ModelBinFromMatArray(weights));
inner_product->create_pipeline(opt);
permute = ncnn::create_layer(ncnn::LayerType::Permute);
ncnn::ParamDict permute_pd;
permute_pd.set(0, 1);
permute->load_param(permute_pd);
permute->create_pipeline(opt);
}
return 0;
} | movq (%rdi), %rax
addq -0x30(%rax), %rdi
jmp 0x3bfcee
| /ysh329[P]ncnn/build_O2/src/layer/x86/deformableconv2d_x86_avx.cpp |
xLearn::Solver::checker(xLearn::HyperParam&) | void Solver::checker(HyperParam& hyper_param) {
if (!checker_.check_param(hyper_param)) {
Color::print_error("Arguments error");
exit(0);
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
addq $0x210, %rdi # imm = 0x210
callq 0x34f4c
testb %al, %al
je 0x2eb99
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rbx
leaq 0x27a29(%rip), %rsi # 0x565d3
leaq 0x27a31(%rip), %rdx # 0x565e2
movq %rbx, %rdi
movq %r14, -0x10(%r14)
callq 0x2a9a2
movq %rbx, %rdi
callq 0x2fa49
leaq 0x8(%rsp), %rdi
callq 0x281d0
xorl %edi, %edi
callq 0x28550
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %r14, %rdi
je 0x2ebe8
callq 0x28440
movq %rbx, %rdi
callq 0x28800
| /aksnzhy[P]xlearn/src/solver/solver.cc |
xLearn::Solver::StartWork() | void Solver::StartWork() {
if (hyper_param_.is_train) {
LOG(INFO) << "Start training work.";
start_train_work();
} else {
LOG(INFO) << "Start inference work.";
start_prediction_work();
}
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, (%rdi)
movq %rdi, %rbx
jne 0x2ecae
leaq 0x40(%rsp), %r14
movl $0x0, 0xc(%rsp)
movq %r14, -0x10(%r14)
leaq 0x278f5(%rip), %rsi # 0x56512
leaq 0x27945(%rip), %rdx # 0x56569
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x27dc6(%rip), %rsi # 0x56a04
leaq 0x27dc8(%rip), %rdx # 0x56a0d
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x20b, %edx # imm = 0x20B
xorl %edi, %edi
callq 0x53d9c
leaq 0x27da2(%rip), %rsi # 0x56a0e
movl $0x14, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ec88
callq 0x28440
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x2ec97
callq 0x28440
leaq 0xc(%rsp), %rdi
callq 0x53e92
movq %rbx, %rdi
callq 0x2eda0
jmp 0x2ed52
leaq 0x40(%rsp), %r14
movl $0x0, 0xc(%rsp)
movq %r14, -0x10(%r14)
leaq 0x2784c(%rip), %rsi # 0x56512
leaq 0x2789c(%rip), %rdx # 0x56569
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x27d1d(%rip), %rsi # 0x56a04
leaq 0x27d1f(%rip), %rdx # 0x56a0d
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x20e, %edx # imm = 0x20E
xorl %edi, %edi
callq 0x53d9c
leaq 0x27d0e(%rip), %rsi # 0x56a23
movl $0x15, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x2ed31
callq 0x28440
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x2ed40
callq 0x28440
leaq 0xc(%rsp), %rdi
callq 0x53e92
movq %rbx, %rdi
callq 0x2f630
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2ed5e
movq %rax, %rbx
jmp 0x2ed7e
jmp 0x2ed65
movq %rax, %rbx
jmp 0x2ed8d
jmp 0x2ed6c
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x2ed7e
callq 0x28440
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x2ed8d
callq 0x28440
leaq 0xc(%rsp), %rdi
callq 0x53e92
movq %rbx, %rdi
callq 0x28800
nop
| /aksnzhy[P]xlearn/src/solver/solver.cc |
xLearn::Solver::start_train_work() | void Solver::start_train_work() {
int epoch = hyper_param_.num_epoch;
bool early_stop = hyper_param_.early_stop &&
!hyper_param_.cross_validation;
int stop_window = hyper_param_.stop_window;
bool quiet = hyper_param_.quiet &&
!hyper_param_.cross_validation;
bool save_model = true;
bool save_txt_model = true;
if (hyper_param_.model_file.compare("none") == 0 ||
hyper_param_.cross_validation) {
save_model = false;
}
if (hyper_param_.txt_model_file.compare("none") == 0 ||
hyper_param_.cross_validation) {
save_txt_model = false;
}
Trainer trainer;
trainer.Initialize(reader_, /* Reader list */
epoch,
model_,
loss_,
metric_,
early_stop,
stop_window,
quiet);
Color::print_action("Start to train ...");
/******************************************************************************
* Training under cross-validation *
******************************************************************************/
if (hyper_param_.cross_validation) {
trainer.CVTrain();
Color::print_action("Finish Cross-Validation");
}
/******************************************************************************
* Original training without cross-validation *
******************************************************************************/
else {
// The training process
trainer.Train();
// Save binary model
if (save_model) {
Timer timer;
timer.tic();
Color::print_action("Start to save model ...");
trainer.SaveModel(hyper_param_.model_file);
Color::print_info(
StringPrintf("Model file: %s", hyper_param_.model_file.c_str())
);
Color::print_info(
StringPrintf("Time cost for saving model: %.2f (sec)", timer.toc())
);
}
// Save TXT model
if (save_txt_model) {
Timer timer;
timer.tic();
Color::print_action("Start to save txt model ...");
trainer.SaveTxtModel(hyper_param_.txt_model_file);
Color::print_info(
StringPrintf("TXT Model file: %s", hyper_param_.txt_model_file.c_str())
);
Color::print_info(
StringPrintf("Time cost for saving txt model: %.2f (sec)", timer.toc())
);
}
Color::print_action("Finish training");
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movb 0x1ee(%rdi), %bl
movb 0x1f4(%rdi), %r14b
movl 0xb0(%rdi), %ebp
movl 0x1f8(%rdi), %r12d
movq %rdi, %r15
xorb $0x1, %bl
andb %bl, %r14b
andb 0x2(%rdi), %bl
addq $0x140, %rdi # imm = 0x140
leaq 0x2a474(%rip), %rsi # 0x59259
movq %rdi, 0x48(%rsp)
callq 0x28120
testl %eax, %eax
je 0x2ee00
cmpb $0x1, 0x1ee(%r15)
movb $0x1, %r13b
jne 0x2ee03
xorl %r13d, %r13d
leaq 0x180(%r15), %rdi
leaq 0x2a448(%rip), %rsi # 0x59259
movq %rdi, 0x40(%rsp)
callq 0x28120
testl %eax, %eax
je 0x2ee2f
cmpb $0x1, 0x1ee(%r15)
movb $0x1, %al
movl %eax, 0x2c(%rsp)
jne 0x2ee37
movl $0x0, 0x2c(%rsp)
vxorps %xmm0, %xmm0, %xmm0
leaq 0x50(%rsp), %rdi
xorl %eax, %eax
leaq 0x250(%r15), %rsi
vmovaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
vmovaps %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
movq 0x248(%r15), %rcx
movq 0x278(%r15), %r8
movq 0x280(%r15), %r9
subq $0x8, %rsp
movzbl %bl, %eax
movl %ebp, %edx
movzbl %r14b, %r10d
pushq %rax
pushq %r12
pushq %r10
callq 0x30300
addq $0x20, %rsp
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x27b9f(%rip), %rsi # 0x56a39
leaq 0x27baa(%rip), %rdx # 0x56a4b
leaq 0x8(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
movl $0x1, 0x4(%rsp)
movl $0x0, (%rsp)
movl $0x20, (%rsi)
movq 0x3e0e4(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r12
leaq 0x27c8b(%rip), %rsi # 0x56b73
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x28510
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r12, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2ef4b
callq 0x28440
cmpb $0x1, 0x1ee(%r15)
jne 0x2f022
leaq 0x50(%rsp), %rdi
callq 0x37b6a
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x27ada(%rip), %rsi # 0x56a4c
leaq 0x27aea(%rip), %rdx # 0x56a63
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
movl $0x1, 0x4(%rsp)
movl $0x0, (%rsp)
movl $0x20, (%rsi)
movq 0x3e011(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %rbx
leaq 0x27bb8(%rip), %rsi # 0x56b73
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x28510
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %rbx, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f559
jmp 0x2f554
leaq 0x50(%rsp), %rdi
callq 0x3759a
testb %r13b, %r13b
je 0x2f263
leaq 0x30(%rsp), %rdi
callq 0x55bf0
movq 0x48(%rsp), %rbx
leaq 0x30(%rsp), %rdi
callq 0x55c28
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x27a07(%rip), %rsi # 0x56a64
leaq 0x27a17(%rip), %rdx # 0x56a7b
callq 0x2a9a2
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsp)
movl $0x0, 0x28(%rsp)
movl $0x20, (%rsi)
movq 0x3df26(%rip), %rdi # 0x6cfb0
callq 0x2aa81
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r15
leaq 0x27acf(%rip), %rsi # 0x56b73
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x28510
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r15, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f109
callq 0x28440
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x30a24
movq (%rbx), %rdx
leaq 0x279a3(%rip), %rsi # 0x56ac3
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsp)
movl $0x20, (%rsi)
movq 0x3de6b(%rip), %rdi # 0x6cfb0
callq 0x2aa81
movq %rax, %r14
leaq 0x26f5f(%rip), %rsi # 0x560b3
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2aa81
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x28510
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f1b7
callq 0x28440
leaq 0x30(%rsp), %rdi
callq 0x55c36
vcvtss2sd %xmm0, %xmm0, %xmm0
leaq 0x278b0(%rip), %rsi # 0x56a7c
leaq 0x8(%rsp), %rdi
movb $0x1, %al
callq 0x53f00
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsp)
movl $0x20, (%rsi)
movq 0x3ddbf(%rip), %rdi # 0x6cfb0
callq 0x2aa81
movq %rax, %r14
leaq 0x26eb3(%rip), %rsi # 0x560b3
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2aa81
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x28510
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f263
callq 0x28440
cmpb $0x0, 0x2c(%rsp)
je 0x2f49e
leaq 0x30(%rsp), %rdi
callq 0x55bf0
leaq 0x30(%rsp), %rdi
callq 0x55c28
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x27812(%rip), %rsi # 0x56aa3
leaq 0x27826(%rip), %rdx # 0x56abe
callq 0x2a9a2
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsp)
movl $0x0, 0x28(%rsp)
movl $0x20, (%rsi)
movq 0x3dcf2(%rip), %rdi # 0x6cfb0
callq 0x2aa81
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
leaq 0x2789b(%rip), %rsi # 0x56b73
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x28510
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f33d
callq 0x28440
movq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x30d92
movq 0x40(%rsp), %rax
movq (%rax), %rdx
leaq 0x27764(%rip), %rsi # 0x56abf
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsp)
movl $0x20, (%rsi)
movq 0x3dc30(%rip), %rdi # 0x6cfb0
callq 0x2aa81
movq %rax, %rbx
leaq 0x26d24(%rip), %rsi # 0x560b3
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2aa81
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x28510
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %rbx, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f3f2
callq 0x28440
leaq 0x30(%rsp), %rdi
callq 0x55c36
vcvtss2sd %xmm0, %xmm0, %xmm0
leaq 0x276cb(%rip), %rsi # 0x56ad2
leaq 0x8(%rsp), %rdi
movb $0x1, %al
callq 0x53f00
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsp)
movl $0x20, (%rsi)
movq 0x3db84(%rip), %rdi # 0x6cfb0
callq 0x2aa81
movq %rax, %rbx
leaq 0x26c78(%rip), %rsi # 0x560b3
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2aa81
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x28510
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %rbx, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f49e
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x27650(%rip), %rsi # 0x56afd
leaq 0x27658(%rip), %rdx # 0x56b0c
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
movl $0x1, 0x4(%rsp)
movl $0x0, (%rsp)
movl $0x20, (%rsi)
movq 0x3dad6(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %rbx
leaq 0x2767d(%rip), %rsi # 0x56b73
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x28510
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %rbx, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2f559
callq 0x28440
leaq 0x50(%rsp), %rdi
callq 0x31100
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
jmp 0x2f5e9
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
jmp 0x2f619
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
jmp 0x2f619
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
jmp 0x2f619
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
jmp 0x2f619
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
jmp 0x2f619
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
jmp 0x2f619
movq %rax, %rbx
jmp 0x2f61e
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
jmp 0x2f619
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
jmp 0x2f619
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %rbp, %rdi
je 0x2f61e
callq 0x28440
leaq 0x50(%rsp), %rdi
callq 0x31100
movq %rbx, %rdi
callq 0x28800
| /aksnzhy[P]xlearn/src/solver/solver.cc |
xLearn::Solver::start_prediction_work() | void Solver::start_prediction_work() {
Color::print_action("Start to predict ...");
Predictor pdc;
pdc.Initialize(reader_[0],
model_,
loss_,
hyper_param_.output_file,
hyper_param_.sign,
hyper_param_.sigmoid,
hyper_param_.res_out);
// Predict and write output
pdc.Predict();
this->out_ = pdc.GetResult();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
leaq 0x38(%rsp), %r15
movq %rdi, %rbx
movq %r15, -0x10(%r15)
leaq 0x274be(%rip), %rsi # 0x56b0d
leaq 0x274cb(%rip), %rdx # 0x56b21
leaq 0x28(%rsp), %rdi
callq 0x2a9a2
leaq 0x10(%rsp), %rsi
movl $0x1, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x20, (%rsi)
movq 0x3d92e(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
leaq 0x274d5(%rip), %rsi # 0x56b73
movl $0xf, %edx
movq %rax, %rdi
callq 0x28510
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x28510
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f703
callq 0x28440
leaq 0x50(%rsp), %rax
vxorps %xmm0, %xmm0, %xmm0
xorl %ecx, %ecx
leaq 0x1a0(%rbx), %r8
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movb $0x0, (%rax)
vmovups %xmm0, 0x10(%rax)
movq %rcx, 0x20(%rax)
movq 0x250(%rbx), %rax
movq 0x248(%rbx), %rdx
movq 0x278(%rbx), %rcx
movzbl 0x1fc(%rbx), %r9d
movzbl 0x1ed(%rbx), %r10d
movq (%rax), %rsi
movzbl 0x1fd(%rbx), %eax
leaq 0x28(%rsp), %rdi
pushq %r10
pushq %rax
callq 0x31122
addq $0x10, %rsp
leaq 0x28(%rsp), %rdi
callq 0x38cc4
leaq 0x60(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3219a
vmovaps 0x10(%rsp), %xmm0
movq 0x290(%rbx), %rdi
vmovups %xmm0, 0x290(%rbx)
vxorps %xmm0, %xmm0, %xmm0
movq 0x20(%rsp), %rax
movq %rax, 0x2a0(%rbx)
vmovaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x2f7cf
callq 0x28440
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2f7cf
callq 0x28440
leaq 0x28(%rsp), %rdi
callq 0x31656
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f7ed
movq %rax, %rbx
jmp 0x2f80e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x31656
jmp 0x2f80e
movq 0x28(%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x2f80e
callq 0x28440
movq %rbx, %rdi
callq 0x28800
| /aksnzhy[P]xlearn/src/solver/solver.cc |
Color::print_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline void print_error(const std::string &out) {
Color::Modifier red(Color::FG_RED);
Color::Modifier bold(Color::BOLD);
Color::Modifier reset(Color::RESET);
std::cout << red << bold << "[ ERROR ] "
<< out << reset << std::endl;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x3d554(%rip), %rdi # 0x6cfb0
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %rbx
movl $0x1f, (%rsi)
movl $0x1, (%r15)
movl $0x0, (%rbx)
callq 0x2aa81
movq %rax, %rdi
movq %r15, %rsi
callq 0x2aa81
leaq 0x270b4(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x28510
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2aa81
movq %rax, %rbx
movq (%rax), %rax
movl $0xa, %esi
movq -0x18(%rax), %rdi
addq %rbx, %rdi
callq 0x28460
movsbl %al, %esi
movq %rbx, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| /aksnzhy[P]xlearn/src/base/format_print.h |
xLearn::Trainer::SaveModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void SaveModel(const std::string& filename) {
CHECK_NE(filename.empty(), true);
CHECK_NE(filename.compare("none"), 0);
model_->Serialize(filename);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x8(%rsi)
movq %rsi, %rbx
je 0x30a6a
leaq 0x28819(%rip), %rsi # 0x59259
movq %rdi, %r14
movq %rbx, %rdi
callq 0x28120
testl %eax, %eax
je 0x30bcc
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x526a0
leaq 0x38(%rsp), %r15
movl $0x2, 0x4(%rsp)
movq %r15, -0x10(%r15)
leaq 0x2623a(%rip), %rsi # 0x56cbc
leaq 0x2628a(%rip), %rdx # 0x56d13
leaq 0x28(%rsp), %rdi
callq 0x2a9a2
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x26296(%rip), %rsi # 0x56d3a
leaq 0x26298(%rip), %rdx # 0x56d43
leaq 0x8(%rsp), %rdi
callq 0x2a9a2
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movl $0x2, %edi
movl $0x4f, %edx
callq 0x53d9c
leaq 0x25bc9(%rip), %rsi # 0x5669e
movl $0x10, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
leaq 0x261d0(%rip), %rsi # 0x56cbc
movl $0x57, %edx
movq %r14, %rdi
callq 0x28510
leaq 0x29274(%rip), %rsi # 0x59d74
movl $0x1, %edx
movq %r14, %rdi
callq 0x28510
movl $0x4f, %esi
movq %r14, %rdi
callq 0x287d0
leaq 0x259ef(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
leaq 0x29dca(%rip), %rsi # 0x5a902
movl $0x10, %edx
movq %r14, %rdi
callq 0x28510
leaq 0x257db(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %r14, %rdi
callq 0x28510
xorl %esi, %esi
cmpq $0x0, 0x8(%rbx)
sete %sil
movq %r14, %rdi
callq 0x28750
leaq 0x2599d(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x25b49(%rip), %rsi # 0x566d3
movl $0x4, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x25789(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %rbx, %rdi
callq 0x28510
movl $0x1, %esi
movq %rbx, %rdi
callq 0x28750
leaq 0x25951(%rip), %rsi # 0x56510
movq %rax, %rdi
callq 0x28470
jmp 0x30d2c
leaq 0x38(%rsp), %r15
movl $0x2, 0x4(%rsp)
movq %r15, -0x10(%r15)
leaq 0x260d8(%rip), %rsi # 0x56cbc
leaq 0x26128(%rip), %rdx # 0x56d13
leaq 0x28(%rsp), %rdi
callq 0x2a9a2
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x26134(%rip), %rsi # 0x56d3a
leaq 0x26136(%rip), %rdx # 0x56d43
leaq 0x8(%rsp), %rdi
callq 0x2a9a2
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movl $0x2, %edi
movl $0x50, %edx
callq 0x53d9c
leaq 0x25a67(%rip), %rsi # 0x5669e
movl $0x10, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
leaq 0x2606e(%rip), %rsi # 0x56cbc
movl $0x57, %edx
movq %r14, %rdi
callq 0x28510
leaq 0x29112(%rip), %rsi # 0x59d74
movl $0x1, %edx
movq %r14, %rdi
callq 0x28510
movl $0x50, %esi
movq %r14, %rdi
callq 0x287d0
leaq 0x2588d(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
leaq 0x260aa(%rip), %rsi # 0x56d44
movl $0x18, %edx
movq %r14, %rdi
callq 0x28510
leaq 0x25679(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %r14, %rdi
callq 0x28510
leaq 0x28597(%rip), %rsi # 0x59259
movq %rbx, %rdi
callq 0x28120
movq %r14, %rdi
movl %eax, %esi
callq 0x287d0
leaq 0x25835(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x29a83(%rip), %rsi # 0x5a775
movl $0x1, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x25621(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %rbx, %rdi
callq 0x28510
movq %rbx, %rdi
xorl %esi, %esi
callq 0x287d0
leaq 0x257ec(%rip), %rsi # 0x56510
movq %rax, %rdi
callq 0x28470
leaq 0x8(%rsp), %rdi
callq 0x281d0
leaq 0x28(%rsp), %rdi
callq 0x281d0
leaq 0x4(%rsp), %rdi
callq 0x53e92
callq 0x28270
jmp 0x30d51
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %r12, %rdi
je 0x30d6a
callq 0x28440
jmp 0x30d6a
jmp 0x30d67
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x30d80
callq 0x28440
jmp 0x30d80
jmp 0x30d7d
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x53e92
movq %rbx, %rdi
callq 0x28800
| /aksnzhy[P]xlearn/src/solver/trainer.h |
xLearn::Model::~Model() | ~Model() { free_model(); } | pushq %rbx
movq %rdi, %rbx
callq 0x52144
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x31699
callq 0x28440
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x316ab
popq %rbx
jmp 0x28440
popq %rbx
retq
movq %rax, %rdi
callq 0x2faf3
nop
| /aksnzhy[P]xlearn/src/data/model_parameters.h |
xLearn::Checker::Initialize(bool, int, char**) | void Checker::Initialize(bool is_train, int argc, char* argv[]) {
is_train_ = is_train;
if (is_train_) { // for training
menu_.push_back(std::string("-s"));
menu_.push_back(std::string("-x"));
menu_.push_back(std::string("-v"));
menu_.push_back(std::string("-p"));
menu_.push_back(std::string("-m"));
menu_.push_back(std::string("-t"));
menu_.push_back(std::string("-l"));
menu_.push_back(std::string("-k"));
menu_.push_back(std::string("-r"));
menu_.push_back(std::string("-b"));
menu_.push_back(std::string("-u"));
menu_.push_back(std::string("-e"));
menu_.push_back(std::string("-f"));
menu_.push_back(std::string("-pre"));
menu_.push_back(std::string("-nthread"));
menu_.push_back(std::string("-block"));
menu_.push_back(std::string("-sw"));
menu_.push_back(std::string("-seed"));
menu_.push_back(std::string("--disk"));
menu_.push_back(std::string("--cv"));
menu_.push_back(std::string("--dis-es"));
menu_.push_back(std::string("--no-norm"));
menu_.push_back(std::string("--no-bin"));
menu_.push_back(std::string("--quiet"));
menu_.push_back(std::string("-alpha"));
menu_.push_back(std::string("-beta"));
menu_.push_back(std::string("-lambda_1"));
menu_.push_back(std::string("-lambda_2"));
} else { // for Prediction
menu_.push_back(std::string("-o"));
menu_.push_back(std::string("-l"));
menu_.push_back(std::string("-nthread"));
menu_.push_back(std::string("-block"));
menu_.push_back(std::string("--sign"));
menu_.push_back(std::string("--sigmoid"));
menu_.push_back(std::string("--disk"));
menu_.push_back(std::string("--no-norm"));
}
// Get the user's input
for (int i = 0; i < argc; ++i) {
args_.push_back(std::string(argv[i]));
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x18(%rsp), %r15
movq %rcx, 0x30(%rsp)
movl %edx, %ebp
movq %rdi, %r14
movb %sil, 0x30(%rdi)
testl %esi, %esi
je 0x32f9a
movq %r15, -0x10(%r15)
leaq 0x265fd(%rip), %rsi # 0x58fa7
leaq 0x265f8(%rip), %rdx # 0x58fa9
leaq 0x8(%rsp), %rdi
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x329d7
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x265c4(%rip), %rsi # 0x58faa
leaq 0x265bf(%rip), %rdx # 0x58fac
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32a0e
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26590(%rip), %rsi # 0x58fad
leaq 0x2658b(%rip), %rdx # 0x58faf
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32a45
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x2655c(%rip), %rsi # 0x58fb0
leaq 0x26557(%rip), %rdx # 0x58fb2
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32a7c
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26528(%rip), %rsi # 0x58fb3
leaq 0x26523(%rip), %rdx # 0x58fb5
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32ab3
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x264f4(%rip), %rsi # 0x58fb6
leaq 0x264ef(%rip), %rdx # 0x58fb8
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32aea
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x264c0(%rip), %rsi # 0x58fb9
leaq 0x264bb(%rip), %rdx # 0x58fbb
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32b21
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x2648c(%rip), %rsi # 0x58fbc
leaq 0x26487(%rip), %rdx # 0x58fbe
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32b58
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26458(%rip), %rsi # 0x58fbf
leaq 0x26453(%rip), %rdx # 0x58fc1
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32b8f
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26424(%rip), %rsi # 0x58fc2
leaq 0x2641f(%rip), %rdx # 0x58fc4
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32bc6
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x263f0(%rip), %rsi # 0x58fc5
leaq 0x263eb(%rip), %rdx # 0x58fc7
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32bfd
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x263bc(%rip), %rsi # 0x58fc8
leaq 0x263b7(%rip), %rdx # 0x58fca
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32c34
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26388(%rip), %rsi # 0x58fcb
leaq 0x26383(%rip), %rdx # 0x58fcd
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32c6b
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26354(%rip), %rsi # 0x58fce
leaq 0x26351(%rip), %rdx # 0x58fd2
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32ca2
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26322(%rip), %rsi # 0x58fd3
leaq 0x26323(%rip), %rdx # 0x58fdb
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32cd9
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x262f4(%rip), %rsi # 0x58fdc
leaq 0x262f3(%rip), %rdx # 0x58fe2
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32d10
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x262c4(%rip), %rsi # 0x58fe3
leaq 0x262c0(%rip), %rdx # 0x58fe6
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32d47
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26291(%rip), %rsi # 0x58fe7
leaq 0x2628f(%rip), %rdx # 0x58fec
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32d7e
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26260(%rip), %rsi # 0x58fed
leaq 0x2625f(%rip), %rdx # 0x58ff3
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32db5
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26230(%rip), %rsi # 0x58ff4
leaq 0x2622d(%rip), %rdx # 0x58ff8
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32dec
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x261fe(%rip), %rsi # 0x58ff9
leaq 0x261ff(%rip), %rdx # 0x59001
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32e23
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x261d0(%rip), %rsi # 0x59002
leaq 0x261d2(%rip), %rdx # 0x5900b
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32e5a
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x261a3(%rip), %rsi # 0x5900c
leaq 0x261a4(%rip), %rdx # 0x59014
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32e91
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26175(%rip), %rsi # 0x59015
leaq 0x26175(%rip), %rdx # 0x5901c
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32ec8
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26146(%rip), %rsi # 0x5901d
leaq 0x26145(%rip), %rdx # 0x59023
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32eff
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x26116(%rip), %rsi # 0x59024
leaq 0x26114(%rip), %rdx # 0x59029
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32f36
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x260e5(%rip), %rsi # 0x5902a
leaq 0x260e7(%rip), %rdx # 0x59033
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32f6d
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x260b8(%rip), %rsi # 0x59034
leaq 0x260ba(%rip), %rdx # 0x5903d
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
jmp 0x33144
movq %r15, -0x10(%r15)
leaq 0x26099(%rip), %rsi # 0x5903e
leaq 0x26094(%rip), %rdx # 0x59040
leaq 0x8(%rsp), %rdi
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x32fd2
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x25fd8(%rip), %rsi # 0x58fb9
leaq 0x25fd3(%rip), %rdx # 0x58fbb
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x33009
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x25fbb(%rip), %rsi # 0x58fd3
leaq 0x25fbc(%rip), %rdx # 0x58fdb
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x33040
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x25f8d(%rip), %rsi # 0x58fdc
leaq 0x25f8c(%rip), %rdx # 0x58fe2
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x33077
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x25fbb(%rip), %rsi # 0x59041
leaq 0x25fba(%rip), %rdx # 0x59047
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x330ae
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x25f8b(%rip), %rsi # 0x59048
leaq 0x25f8d(%rip), %rdx # 0x59051
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x330e5
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x25ef9(%rip), %rsi # 0x58fed
leaq 0x25ef8(%rip), %rdx # 0x58ff3
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3311c
callq 0x28440
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x25ed7(%rip), %rsi # 0x59002
leaq 0x25ed9(%rip), %rdx # 0x5900b
callq 0x2a9a2
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x33153
callq 0x28440
testl %ebp, %ebp
jle 0x331a4
addq $0x18, %r14
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
leaq 0x2f(%rsp), %r12
movl %ebp, %ebp
xorl %ebx, %ebx
movq 0x30(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x281a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x36a50
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3319c
callq 0x28440
incq %rbx
cmpq %rbx, %rbp
jne 0x3316e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33274
jmp 0x33261
jmp 0x33261
jmp 0x33274
jmp 0x33274
jmp 0x33261
jmp 0x33261
jmp 0x33274
jmp 0x33274
jmp 0x33261
jmp 0x33261
jmp 0x33274
jmp 0x33274
jmp 0x33261
jmp 0x33261
jmp 0x33274
jmp 0x33274
jmp 0x33261
jmp 0x33261
jmp 0x33274
jmp 0x33274
jmp 0x33261
jmp 0x33261
jmp 0x33274
jmp 0x33274
jmp 0x33261
jmp 0x33261
jmp 0x33274
jmp 0x33274
jmp 0x33261
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
jne 0x33286
jmp 0x3328b
jmp 0x33274
jmp 0x33274
movq %rax, %rbx
jmp 0x3328b
movq 0x8(%rsp), %rdi
movq %rax, %rbx
cmpq %r13, %rdi
je 0x3328b
callq 0x28440
movq %rbx, %rdi
callq 0x28800
nop
| /aksnzhy[P]xlearn/src/solver/checker.cc |
xLearn::Checker::check_train_param(xLearn::HyperParam&) | bool Checker::check_train_param(HyperParam& hyper_param) {
bool bo = true;
/*********************************************************
* Check file path *
*********************************************************/
if (hyper_param.from_file) {
if (!FileExist(hyper_param.train_set_file.c_str())) {
Color::print_error(
StringPrintf("Training data file: %s does not exist.",
hyper_param.train_set_file.c_str())
);
bo = false;
}
if (!hyper_param.validate_set_file.empty() &&
!FileExist(hyper_param.validate_set_file.c_str())) {
Color::print_error(
StringPrintf("Validation data file: %s does not exist.",
hyper_param.validate_set_file.c_str())
);
bo = false;
}
} else {
if (hyper_param.train_dataset == nullptr) {
Color::print_error(
StringPrintf("Training dataset is None, please check!")
);
bo = false;
}
}
/*********************************************************
* Check invalid value *
*********************************************************/
if (hyper_param.thread_number < 0) {
Color::print_error(
StringPrintf("The thread number must be greater than zero: %d.",
hyper_param.thread_number)
);
bo = false;
}
if (hyper_param.loss_func.compare("unknow") == 0) {
Color::print_error(
StringPrintf("The task can only be 'binary' or 'reg'.")
);
bo = false;
}
if (hyper_param.metric.compare("acc") != 0 &&
hyper_param.metric.compare("prec") != 0 &&
hyper_param.metric.compare("recall") != 0 &&
hyper_param.metric.compare("f1") != 0 &&
hyper_param.metric.compare("auc") != 0 &&
hyper_param.metric.compare("mae") != 0 &&
hyper_param.metric.compare("mape") != 0 &&
hyper_param.metric.compare("rmsd") != 0 &&
hyper_param.metric.compare("rmse") != 0 &&
hyper_param.metric.compare("none") != 0) {
Color::print_error(
StringPrintf("Unknow evaluation metric: %s.",
hyper_param.metric.c_str())
);
bo = false;
}
if (hyper_param.opt_type.compare("sgd") != 0 &&
hyper_param.opt_type.compare("ftrl") != 0 &&
hyper_param.opt_type.compare("adagrad") != 0) {
Color::print_error(
StringPrintf("Unknow optimization method: %s.",
hyper_param.opt_type.c_str())
);
bo = false;
}
if (hyper_param.num_K > 999999) {
Color::print_error(
StringPrintf("Invalid size of K: %d. "
"Size of K must be greater than zero.",
hyper_param.num_K)
);
bo = false;
}
if (hyper_param.num_folds <= 0) {
Color::print_error(
StringPrintf("Invalid size of folds: %d. "
"Size of folds must be greater than zero.",
hyper_param.num_folds)
);
bo = false;
}
if (hyper_param.num_epoch <= 0) {
Color::print_error(
StringPrintf("Invalid number of epoch: %d. "
"Number of epoch must be greater than zero.",
hyper_param.num_epoch)
);
bo = false;
}
if (!bo) return false;
/*********************************************************
* Check warning and fix conflict *
*********************************************************/
check_conflict_train(hyper_param);
/*********************************************************
* Set default value *
*********************************************************/
if (hyper_param.model_file.empty() && !hyper_param.cross_validation) {
hyper_param.model_file = hyper_param.train_set_file + ".model";
}
if (hyper_param.metric.compare("rmse") == 0) {
hyper_param.metric = "rmsd";
}
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpb $0x1, 0x1ec(%rsi)
movq %rsi, %rbx
jne 0x35122
movq 0xc8(%rbx), %rdi
callq 0x368b3
movl %eax, %ebp
testb %al, %al
jne 0x3504d
movq 0xc8(%rbx), %rdx
leaq 0x240b8(%rip), %rsi # 0x59052
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x37fe8(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x21b68(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3504d
callq 0x28440
cmpq $0x0, 0x110(%rbx)
je 0x351ef
movq 0x108(%rbx), %rdi
callq 0x368b3
testb %al, %al
jne 0x351ef
movq 0x108(%rbx), %rdx
leaq 0x2459a(%rip), %rsi # 0x59617
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x37f05(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x21a85(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
jmp 0x351da
cmpq $0x0, 0x128(%rbx)
movb $0x1, %bpl
jne 0x351ef
leaq 0x24506(%rip), %rsi # 0x59640
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x37e48(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x219c8(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x351ed
callq 0x28440
xorl %ebp, %ebp
movl 0x68(%rbx), %edx
testl %edx, %edx
jns 0x352b6
leaq 0x24467(%rip), %rsi # 0x59668
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x37d81(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x21901(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x352b4
callq 0x28440
xorl %ebp, %ebp
leaq 0x28(%rbx), %rdi
leaq 0x243d8(%rip), %rsi # 0x59699
callq 0x28120
testl %eax, %eax
jne 0x3538a
leaq 0x243cb(%rip), %rsi # 0x596a0
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x37cad(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x2182d(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35388
callq 0x28440
xorl %ebp, %ebp
leaq 0x48(%rbx), %r14
leaq 0x23e25(%rip), %rsi # 0x591ba
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23e12(%rip), %rsi # 0x591be
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23e00(%rip), %rsi # 0x591c3
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23df0(%rip), %rsi # 0x591ca
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23ddc(%rip), %rsi # 0x591cd
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23dc9(%rip), %rsi # 0x591d1
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23db6(%rip), %rsi # 0x591d5
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23da8(%rip), %rsi # 0x591da
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23d9a(%rip), %rsi # 0x591df
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
leaq 0x23e01(%rip), %rsi # 0x59259
movq %r14, %rdi
callq 0x28120
testl %eax, %eax
je 0x3549a
movq (%r14), %rdx
leaq 0x10(%rsp), %r15
leaq 0x24255(%rip), %rsi # 0x596c8
xorl %eax, %eax
movq %r15, %rdi
callq 0x53f00
movq %r15, %rdi
callq 0x2fa49
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35498
callq 0x28440
xorl %ebp, %ebp
leaq 0x70(%rbx), %r15
leaq 0x21369(%rip), %rsi # 0x5680e
movq %r15, %rdi
callq 0x28120
testl %eax, %eax
je 0x355a2
leaq 0x21356(%rip), %rsi # 0x56812
movq %r15, %rdi
callq 0x28120
testl %eax, %eax
je 0x355a2
leaq 0x20b9e(%rip), %rsi # 0x56071
movq %r15, %rdi
callq 0x28120
testl %eax, %eax
je 0x355a2
movq (%r15), %rdx
leaq 0x241f9(%rip), %rsi # 0x596e6
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x37a95(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x21615(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r15, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x355a0
callq 0x28440
xorl %ebp, %ebp
movl 0xc0(%rbx), %edx
cmpl $0xf4240, %edx # imm = 0xF4240
jb 0x35670
leaq 0x2414b(%rip), %rsi # 0x59706
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x379c7(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x21547(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r15, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3566e
callq 0x28440
xorl %ebp, %ebp
movl 0x1f0(%rbx), %edx
testl %edx, %edx
jle 0x35742
movl 0xb0(%rbx), %edx
testl %edx, %edx
jle 0x3580a
testb %bpl, %bpl
je 0x358c4
movq %rbx, %rsi
callq 0x35d3e
cmpq $0x0, 0x148(%rbx)
jne 0x35708
cmpb $0x0, 0x1ee(%rbx)
jne 0x35708
leaq 0x20(%rsp), %r12
leaq 0x10(%rsp), %r15
movq %r12, -0x10(%r12)
movq %r15, %rdi
movq 0xc8(%rbx), %rsi
movq 0xd0(%rbx), %rdx
addq %rsi, %rdx
callq 0x323d8
leaq 0x23f31(%rip), %rsi # 0x59610
movq %r15, %rdi
callq 0x28860
leaq 0x10(%rsp), %r15
leaq 0x140(%rbx), %rdi
movq %r15, %rsi
callq 0x28570
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x35708
callq 0x28440
leaq 0x23ad0(%rip), %rsi # 0x591df
movq %r14, %rdi
callq 0x28120
movb $0x1, %bpl
testl %eax, %eax
jne 0x358c6
movq 0x50(%rbx), %rdx
leaq 0x23aad(%rip), %rcx # 0x591da
movl $0x4, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x286c0
jmp 0x358c6
leaq 0x23ff9(%rip), %rsi # 0x59742
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x37839(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x213b9(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %r14, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x357fc
callq 0x28440
movl 0xb0(%rbx), %edx
testl %edx, %edx
jg 0x358c4
leaq 0x23f75(%rip), %rsi # 0x59786
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x53f00
leaq 0xc(%rsp), %rsi
movl $0x1, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl $0x1f, (%rsi)
movq 0x37771(%rip), %rdi # 0x6cfb0
callq 0x2aa81
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
leaq 0x212f1(%rip), %rsi # 0x56b49
movl $0xf, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x28510
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2aa81
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x28460
movsbl %al, %esi
movq %rbx, %rdi
callq 0x28050
movq %rax, %rdi
callq 0x28300
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x358c4
callq 0x28440
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x358f6
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r12, %rdi
jne 0x35907
jmp 0x3590c
jmp 0x358f6
jmp 0x358f6
jmp 0x358f6
jmp 0x358f6
jmp 0x358f6
jmp 0x358f6
jmp 0x358f6
jmp 0x358f6
leaq 0x20(%rsp), %rcx
movq %rax, %rbx
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x3590c
callq 0x28440
movq %rbx, %rdi
callq 0x28800
| /aksnzhy[P]xlearn/src/solver/checker.cc |
xLearn::OndiskReader::Samples(xLearn::DMatrix*&) | index_t OndiskReader::Samples(DMatrix* &matrix) {
// Convert MB to Byte
uint64 read_byte = block_size_ * 1024 * 1024;
// Read a block of data from disk file
size_t ret = ReadDataFromDisk(file_ptr_, block_, read_byte);
if (ret == 0) {
matrix = nullptr;
return 0;
} else if (ret == read_byte) {
// Find the last '\n', and shrink back file pointer
shrink_block(block_, &ret, file_ptr_);
} // else ret < read_byte: we don't need shrink_block()
// Parse block to data_sample_
parser_->Parse(block_, ret, data_samples_, true);
matrix = &data_samples_;
return data_samples_.row_length;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xc8(%rdi), %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc0(%rdi), %rsi
movq 0xd8(%rdi), %rdi
shlq $0x14, %r12
movq %r12, %rdx
callq 0x3c660
testq %rax, %rax
je 0x3bd4d
movq %rax, %r15
cmpq %r12, %rax
jne 0x3bd20
movq 0xc0(%r14), %rax
movq 0xd8(%r14), %rdi
incq %r12
movl $0x1, %esi
movq %r12, %r15
decq %rsi
cmpb $0xa, -0x2(%rax,%r15)
leaq -0x1(%r15), %r15
jne 0x3bd07
movl $0x1, %edx
callq 0x284f0
movq 0x90(%r14), %rdi
movq 0xc0(%r14), %rsi
leaq 0x28(%r14), %r12
movl $0x1, %r8d
movq %r15, %rdx
movq %r12, %rcx
movq (%rdi), %rax
callq *0x10(%rax)
movq %r12, (%rbx)
movl 0x38(%r14), %eax
jmp 0x3bd56
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /aksnzhy[P]xlearn/src/reader/reader.cc |
xLearn::FromDMReader::Initialize(xLearn::DMatrix*&) | void FromDMReader::Initialize(xLearn::DMatrix* &dmatrix) {
this->data_ptr_ = dmatrix;
has_label_ = this->data_ptr_->has_label;
num_samples_ = this->data_ptr_->row_length;
data_samples_.ReAlloc(num_samples_, has_label_);
// for shuffle
order_.resize(num_samples_);
for (int i = 0; i < order_.size(); ++i) {
order_[i] = i;
}
} | pushq %rbx
movq (%rsi), %rax
movq %rdi, %rbx
movq %rax, 0xd8(%rdi)
movzbl 0x60(%rax), %edx
movb %dl, 0x98(%rdi)
movl 0x10(%rax), %esi
movl %esi, 0xe0(%rdi)
addq $0x28, %rdi
callq 0x3cf5e
movl 0xe0(%rbx), %esi
leaq 0xe8(%rbx), %rdi
callq 0x3cfe8
movq 0xe8(%rbx), %rax
movq 0xf0(%rbx), %rdx
subq %rax, %rdx
je 0x3be3a
vpmovsxbq 0x1a459(%rip), %zmm1 # 0x56218
vpmovsxbq 0x1a457(%rip), %zmm2 # 0x56220
vpmovsxbd 0x1e74d(%rip), %zmm3 # 0x5a520
vpbroadcastq 0x1e72b(%rip), %zmm4 # 0x5a508
vpbroadcastd 0x1e729(%rip), %zmm5 # 0x5a510
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
leaq 0xf(%rdx), %rcx
decq %rdx
vpbroadcastq %rdx, %zmm0
andq $-0x10, %rcx
xorl %edx, %edx
vpcmpleuq %zmm0, %zmm2, %k0
vpcmpleuq %zmm0, %zmm1, %k1
vpaddq %zmm4, %zmm2, %zmm2
vpaddq %zmm4, %zmm1, %zmm1
kunpckbw %k0, %k1, %k1
vmovdqu32 %zmm3, (%rax,%rdx,4) {%k1}
addq $0x10, %rdx
vpaddd %zmm5, %zmm3, %zmm3
cmpq %rdx, %rcx
jne 0x3be06
popq %rbx
vzeroupper
retq
nop
| /aksnzhy[P]xlearn/src/reader/reader.cc |
GetLine(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | inline void GetLine(FILE *file, std::string &str_line) {
CHECK_NOTNULL(file);
scoped_array<char> line(new char[kMaxLineSize]);
CHECK_NOTNULL(fgets(line.get(), kMaxLineSize, file));
int read_len = strlen(line.get());
if (line[read_len-1] != '\n') {
LOG(FATAL) << "Encountered a too-long line: \
Cannot find the '\\n' char. \
Please check the data.";
} else {
line[read_len-1] = '\0';
// Handle the format in DOS and Windows
if (read_len > 1 && line[read_len-2] == '\r') {
line[read_len-2] = '\0';
}
}
str_line.assign(line.get());
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0x3c1a7
movq %rdi, %r15
movl $0xa00000, %edi # imm = 0xA00000
movq %rsi, %rbx
callq 0x28040
movl $0xa00000, %esi # imm = 0xA00000
movq %rax, %r14
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %r15, %rdx
callq 0x28700
testq %rax, %rax
je 0x3c2ae
movq %r14, %rdi
callq 0x281c0
movq %rax, %r14
decl %eax
leaq 0x8(%rsp), %rdi
movslq %eax, %r15
movq %r15, %rsi
callq 0x3e056
cmpb $0xa, (%rax)
jne 0x3c0cb
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3e056
movb $0x0, (%rax)
cmpl $0x2, %r14d
jl 0x3c16a
addl $-0x2, %r14d
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3e056
cmpb $0xd, (%rax)
jne 0x3c16a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3e056
movb $0x0, (%rax)
jmp 0x3c16a
leaq 0x40(%rsp), %r14
movl $0x3, 0x4(%rsp)
movq %r14, -0x10(%r14)
leaq 0x1db55(%rip), %rsi # 0x59c38
leaq 0x1dba5(%rip), %rdx # 0x59c8f
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1e5c9(%rip), %rsi # 0x5a6cd
leaq 0x1e5c9(%rip), %rdx # 0x5a6d4
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x3, %edi
movl $0xb2, %edx
callq 0x53d9c
leaq 0x1e5c6(%rip), %rsi # 0x5a6fb
movl $0x74, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3c151
callq 0x28440
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3c160
callq 0x28440
leaq 0x4(%rsp), %rdi
callq 0x53e92
movq 0x8(%rsp), %r14
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x281c0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x286c0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3c19d
callq 0x285a0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x40(%rsp), %r14
movl $0x2, 0x8(%rsp)
movq %r14, -0x10(%r14)
leaq 0x1da79(%rip), %rsi # 0x59c38
leaq 0x1dac9(%rip), %rdx # 0x59c8f
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1e4ed(%rip), %rsi # 0x5a6cd
leaq 0x1e4ed(%rip), %rdx # 0x5a6d4
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x2, %edi
movl $0xad, %edx
callq 0x53d9c
leaq 0x1a0c5(%rip), %rsi # 0x562d6
movl $0xd, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x1da10(%rip), %rsi # 0x59c38
movl $0x57, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x1db38(%rip), %rsi # 0x59d74
movl $0x1, %edx
movq %rbx, %rdi
callq 0x28510
movl $0xad, %esi
movq %rbx, %rdi
callq 0x287d0
leaq 0x1a2b3(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x1a0d9(%rip), %rsi # 0x5634d
movl $0x4, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x1a4a4(%rip), %rsi # 0x5672c
movq %rbx, %rdi
callq 0x28470
leaq 0x10(%rsp), %rdi
callq 0x281d0
leaq 0x30(%rsp), %rdi
callq 0x281d0
leaq 0x8(%rsp), %rdi
jmp 0x3c3b0
leaq 0x40(%rsp), %r14
movl $0x2, 0x4(%rsp)
movq %r14, -0x10(%r14)
leaq 0x1d972(%rip), %rsi # 0x59c38
leaq 0x1d9c2(%rip), %rdx # 0x59c8f
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1e3e6(%rip), %rsi # 0x5a6cd
leaq 0x1e3e6(%rip), %rdx # 0x5a6d4
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x2, %edi
movl $0xaf, %edx
callq 0x53d9c
leaq 0x19fbe(%rip), %rsi # 0x562d6
movl $0xd, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x1d909(%rip), %rsi # 0x59c38
movl $0x57, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x1da31(%rip), %rsi # 0x59d74
movl $0x1, %edx
movq %rbx, %rdi
callq 0x28510
movl $0xaf, %esi
movq %rbx, %rdi
callq 0x287d0
leaq 0x1a1ac(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x1e35a(%rip), %rsi # 0x5a6d5
movl $0x25, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x1a39d(%rip), %rsi # 0x5672c
movq %rbx, %rdi
callq 0x28470
leaq 0x10(%rsp), %rdi
callq 0x281d0
leaq 0x30(%rsp), %rdi
callq 0x281d0
leaq 0x4(%rsp), %rdi
callq 0x53e92
callq 0x28270
jmp 0x3c401
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x3c3d5
callq 0x28440
jmp 0x3c3d5
jmp 0x3c3e6
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3c3f5
callq 0x28440
jmp 0x3c3f5
movq %rax, %rbx
jmp 0x3c413
jmp 0x3c3ed
movq %rax, %rbx
jmp 0x3c422
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x53e92
jmp 0x3c440
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x3c413
callq 0x28440
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3c422
callq 0x28440
leaq 0x4(%rsp), %rdi
callq 0x53e92
jmp 0x3c431
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3c440
callq 0x285a0
movq %rbx, %rdi
callq 0x28800
| /aksnzhy[P]xlearn/src/base/file_util.h |
xLearn::Reader::CreateParser(char const*) | Parser* CreateParser(const char* format_name) {
return CREATE_PARSER(format_name);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movb 0x305f1(%rip), %al # 0x6d618
movq %rsi, %rbx
testb %al, %al
je 0x3d073
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %rbx, %rsi
movq %r14, %rdi
callq 0x281a0
leaq 0x30596(%rip), %rdi # 0x6d5e0
movq %r14, %rsi
callq 0x3fd8c
leaq 0x18(%rsp), %rcx
movq %rax, %rbx
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x3d068
callq 0x28440
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x28c12
jmp 0x3d02e
leaq 0x18(%rsp), %rcx
movq %rax, %rbx
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x3d090
callq 0x28440
movq %rbx, %rdi
callq 0x28800
| /aksnzhy[P]xlearn/src/reader/reader.h |
xLearn::DMatrix::Serialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Serialize(const std::string& filename) {
CHECK_NE(filename.empty(), true);
CHECK_EQ(row_length, row.size());
CHECK_EQ(row_length, Y.size());
CHECK_EQ(row_length, norm.size());
#ifndef _MSC_VER
FILE* file = OpenFileOrDie(filename.c_str(), "w");
#else
FILE* file = OpenFileOrDie(filename.c_str(), "wb");
#endif
// Write hash_value
WriteDataToDisk(file, (char*)&hash_value_1, sizeof(hash_value_1));
WriteDataToDisk(file, (char*)&hash_value_2, sizeof(hash_value_2));
// Write row_length
WriteDataToDisk(file, (char*)&row_length, sizeof(row_length));
// Write row
for (size_t i = 0; i < row_length; ++i) {
WriteVectorToFile(file, *(row[i]));
}
// Write Y
WriteVectorToFile(file, Y);
// Write norm
WriteVectorToFile(file, norm);
// Write has_label
WriteDataToDisk(file, (char*)&has_label, sizeof(has_label));
// Write pos
WriteDataToDisk(file, (char*)&pos, sizeof(pos));
Close(file);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
cmpq $0x0, 0x8(%rsi)
movq %rsi, %r15
je 0x3d1bb
movq 0x20(%rdi), %rcx
movl 0x10(%rdi), %eax
leaq 0x10(%rdi), %r14
movq %rdi, %rbx
subq 0x18(%rdi), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jne 0x3d31d
movq 0x38(%rbx), %rcx
subq 0x30(%rbx), %rcx
sarq $0x2, %rcx
cmpq %rax, %rcx
jne 0x3d47e
movq 0x50(%rbx), %rcx
subq 0x48(%rbx), %rcx
sarq $0x2, %rcx
cmpq %rax, %rcx
jne 0x3d5df
movq (%r15), %rdi
leaq 0x19c32(%rip), %rsi # 0x56d38
leaq 0x30(%rbx), %r13
leaq 0x48(%rbx), %r12
callq 0x3a196
movl $0x8, %edx
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3f17c
leaq 0x8(%rbx), %rsi
movl $0x8, %edx
movq %r15, %rdi
callq 0x3f17c
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f17c
cmpl $0x0, 0x10(%rbx)
je 0x3d16b
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq %r15, %rdi
movq (%rax,%r14,8), %rsi
callq 0x3f60f
movl 0x10(%rbx), %eax
incq %r14
cmpq %rax, %r14
jb 0x3d150
movq %r15, %rdi
movq %r13, %rsi
callq 0x3f907
movq %r15, %rdi
movq %r12, %rsi
callq 0x3f907
leaq 0x60(%rbx), %rsi
movl $0x1, %edx
movq %r15, %rdi
callq 0x3f17c
addq $0x64, %rbx
movl $0x4, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3f17c
movq %r15, %rdi
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3c448
leaq 0x40(%rsp), %r14
movl $0x2, 0xc(%rsp)
movq %r14, -0x10(%r14)
leaq 0x1d6c5(%rip), %rsi # 0x5a898
leaq 0x1d71a(%rip), %rdx # 0x5a8f4
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1d73a(%rip), %rsi # 0x5a92f
leaq 0x1d73c(%rip), %rdx # 0x5a938
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x2, %edi
movl $0x14e, %edx # imm = 0x14E
callq 0x53d9c
leaq 0x19478(%rip), %rsi # 0x5669e
movl $0x10, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x1d65b(%rip), %rsi # 0x5a898
movl $0x5c, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x1cb23(%rip), %rsi # 0x59d74
movl $0x1, %edx
movq %rbx, %rdi
callq 0x28510
movl $0x14e, %esi # imm = 0x14E
movq %rbx, %rdi
callq 0x287d0
leaq 0x1929e(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x1d679(%rip), %rsi # 0x5a902
movl $0x10, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x1908a(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %rbx, %rdi
callq 0x28510
xorl %esi, %esi
cmpq $0x0, 0x8(%r15)
sete %sil
movq %rbx, %rdi
callq 0x28750
leaq 0x1924c(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %rbx
callq 0x28510
leaq 0x193f8(%rip), %rsi # 0x566d3
movl $0x4, %edx
movq %rbx, %rdi
callq 0x28510
leaq 0x19038(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %rbx, %rdi
callq 0x28510
movl $0x1, %esi
movq %rbx, %rdi
callq 0x28750
leaq 0x19200(%rip), %rsi # 0x56510
movq %rax, %rdi
callq 0x28470
jmp 0x3d73b
leaq 0x40(%rsp), %r12
movl $0x2, 0xc(%rsp)
movq %r12, -0x10(%r12)
leaq 0x1d562(%rip), %rsi # 0x5a898
leaq 0x1d5b7(%rip), %rdx # 0x5a8f4
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1d5d8(%rip), %rsi # 0x5a92f
leaq 0x1d5da(%rip), %rdx # 0x5a938
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x2, %edi
movl $0x14f, %edx # imm = 0x14F
callq 0x53d9c
leaq 0x1cb39(%rip), %rsi # 0x59ec1
movl $0x10, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
leaq 0x1d4f9(%rip), %rsi # 0x5a898
movl $0x5c, %edx
movq %r15, %rdi
callq 0x28510
leaq 0x1c9c1(%rip), %rsi # 0x59d74
movl $0x1, %edx
movq %r15, %rdi
callq 0x28510
movl $0x14f, %esi # imm = 0x14F
movq %r15, %rdi
callq 0x287d0
leaq 0x1913c(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
leaq 0x1d8e0(%rip), %rsi # 0x5accb
movl $0xa, %edx
movq %r15, %rdi
callq 0x28510
leaq 0x18f28(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %r15, %rdi
callq 0x28510
movl (%r14), %esi
movq %r15, %rdi
callq 0x282f0
leaq 0x190f2(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
leaq 0x1d504(%rip), %rsi # 0x5a939
movl $0xa, %edx
movq %r14, %rdi
callq 0x28510
leaq 0x18ede(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %r14, %rdi
callq 0x28510
movq 0x20(%rbx), %rsi
subq 0x18(%rbx), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x282f0
leaq 0x1909f(%rip), %rsi # 0x56510
movq %rax, %rdi
callq 0x28470
jmp 0x3d73b
leaq 0x40(%rsp), %r12
movl $0x2, 0xc(%rsp)
movq %r12, -0x10(%r12)
leaq 0x1d401(%rip), %rsi # 0x5a898
leaq 0x1d456(%rip), %rdx # 0x5a8f4
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1d477(%rip), %rsi # 0x5a92f
leaq 0x1d479(%rip), %rdx # 0x5a938
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x2, %edi
movl $0x150, %edx # imm = 0x150
callq 0x53d9c
leaq 0x1c9d8(%rip), %rsi # 0x59ec1
movl $0x10, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
leaq 0x1d398(%rip), %rsi # 0x5a898
movl $0x5c, %edx
movq %r15, %rdi
callq 0x28510
leaq 0x1c860(%rip), %rsi # 0x59d74
movl $0x1, %edx
movq %r15, %rdi
callq 0x28510
movl $0x150, %esi # imm = 0x150
movq %r15, %rdi
callq 0x287d0
leaq 0x18fdb(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
leaq 0x1d77f(%rip), %rsi # 0x5accb
movl $0xa, %edx
movq %r15, %rdi
callq 0x28510
leaq 0x18dc7(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %r15, %rdi
callq 0x28510
movl (%r14), %esi
movq %r15, %rdi
callq 0x282f0
leaq 0x18f91(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
leaq 0x1d3ae(%rip), %rsi # 0x5a944
movl $0x8, %edx
movq %r14, %rdi
callq 0x28510
leaq 0x18d7d(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %r14, %rdi
callq 0x28510
movq 0x38(%rbx), %rsi
subq 0x30(%rbx), %rsi
sarq $0x2, %rsi
movq %r14, %rdi
callq 0x282f0
leaq 0x18f3e(%rip), %rsi # 0x56510
movq %rax, %rdi
callq 0x28470
jmp 0x3d73b
leaq 0x40(%rsp), %r12
movl $0x2, 0xc(%rsp)
movq %r12, -0x10(%r12)
leaq 0x1d2a0(%rip), %rsi # 0x5a898
leaq 0x1d2f5(%rip), %rdx # 0x5a8f4
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1d316(%rip), %rsi # 0x5a92f
leaq 0x1d318(%rip), %rdx # 0x5a938
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x2, %edi
movl $0x151, %edx # imm = 0x151
callq 0x53d9c
leaq 0x1c877(%rip), %rsi # 0x59ec1
movl $0x10, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
leaq 0x1d237(%rip), %rsi # 0x5a898
movl $0x5c, %edx
movq %r15, %rdi
callq 0x28510
leaq 0x1c6ff(%rip), %rsi # 0x59d74
movl $0x1, %edx
movq %r15, %rdi
callq 0x28510
movl $0x151, %esi # imm = 0x151
movq %r15, %rdi
callq 0x287d0
leaq 0x18e7a(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %r15
callq 0x28510
leaq 0x1d61e(%rip), %rsi # 0x5accb
movl $0xa, %edx
movq %r15, %rdi
callq 0x28510
leaq 0x18c66(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %r15, %rdi
callq 0x28510
movl (%r14), %esi
movq %r15, %rdi
callq 0x282f0
leaq 0x18e30(%rip), %rsi # 0x56510
movl $0x1, %edx
movq %rax, %rdi
movq %rax, %r14
callq 0x28510
leaq 0x1d256(%rip), %rsi # 0x5a94d
movl $0xb, %edx
movq %r14, %rdi
callq 0x28510
leaq 0x18c1c(%rip), %rsi # 0x56327
movl $0x3, %edx
movq %r14, %rdi
callq 0x28510
movq 0x50(%rbx), %rsi
subq 0x48(%rbx), %rsi
sarq $0x2, %rsi
movq %r14, %rdi
callq 0x282f0
leaq 0x18ddd(%rip), %rsi # 0x56510
movq %rax, %rdi
callq 0x28470
leaq 0x10(%rsp), %rdi
callq 0x281d0
leaq 0x30(%rsp), %rdi
callq 0x281d0
leaq 0xc(%rsp), %rdi
callq 0x53e92
callq 0x28270
jmp 0x3d762
jmp 0x3d762
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r13, %rdi
je 0x3d791
callq 0x28440
jmp 0x3d791
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r12, %rdi
je 0x3d7a0
callq 0x28440
jmp 0x3d7a0
jmp 0x3d78e
jmp 0x3d78e
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
jne 0x3d7aa
jmp 0x3d7ba
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d7ba
callq 0x28440
jmp 0x3d7ba
jmp 0x3d7b7
jmp 0x3d7b7
jmp 0x3d7b7
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x53e92
movq %rbx, %rdi
callq 0x28800
| /aksnzhy[P]xlearn/src/data/data_structure.h |
xLearn::OndiskReader::SetShuffle(bool) | void inline SetShuffle(bool shuffle) {
if (shuffle == true) {
LOG(ERR) << "Cannot set shuffle for OndiskReader.";
}
this->shuffle_ = false;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x3da47
leaq 0x40(%rsp), %r14
movl $0x2, 0xc(%rsp)
movq %r14, -0x10(%r14)
leaq 0x191c3(%rip), %rsi # 0x56b83
leaq 0x19212(%rip), %rdx # 0x56bd9
leaq 0x30(%rsp), %rdi
callq 0x2a9a2
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1cfd1(%rip), %rsi # 0x5a9b2
leaq 0x1cfd4(%rip), %rdx # 0x5a9bc
leaq 0x10(%rsp), %rdi
callq 0x2a9a2
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movl $0x2, %edi
movl $0x120, %edx # imm = 0x120
callq 0x53d9c
leaq 0x1cfab(%rip), %rsi # 0x5a9bd
movl $0x24, %edx
movq %rax, %rdi
callq 0x28510
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3da2e
callq 0x28440
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3da3d
callq 0x28440
leaq 0xc(%rsp), %rdi
callq 0x53e92
movb $0x0, 0x99(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x3da74
movq %rax, %rbx
jmp 0x3da83
movq 0x10(%rsp), %rdi
movq %rax, %rbx
cmpq %r15, %rdi
je 0x3da74
callq 0x28440
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3da83
callq 0x28440
leaq 0xc(%rsp), %rdi
callq 0x53e92
movq %rbx, %rdi
callq 0x28800
nop
| /aksnzhy[P]xlearn/src/reader/reader.h |
xLearn::FromDMReader::SetShuffle(bool) | virtual inline void SetShuffle(bool shuffle) {
this->shuffle_ = shuffle;
if (shuffle_ && !order_.empty()) {
srand(this->seed_);
random_shuffle(order_.begin(), order_.end());
}
} | movb %sil, 0x99(%rdi)
testl %esi, %esi
je 0x3dbbe
pushq %r15
pushq %r14
pushq %rbx
movq 0xe8(%rdi), %rax
movq %rdi, %rbx
cmpq 0xf0(%rdi), %rax
je 0x3dbb9
movl 0xd0(%rbx), %edi
callq 0x28450
movq 0xe8(%rbx), %r14
movq 0xf0(%rbx), %rbx
cmpq %rbx, %r14
je 0x3dbb9
leaq 0x4(%r14), %rax
cmpq %rbx, %rax
je 0x3dbb9
movl $0x4, %r15d
callq 0x28100
cltq
movq %r15, %rcx
sarq $0x2, %rcx
incq %rcx
cqto
idivq %rcx
leaq (,%rdx,4), %rax
cmpq %rax, %r15
je 0x3dbab
leaq (%r14,%rdx,4), %rcx
leaq (%r14,%r15), %rax
movl (%rax), %edx
movl (%rcx), %esi
movl %esi, (%rax)
movl %edx, (%rcx)
leaq 0x4(%r14,%r15), %rax
addq $0x4, %r15
cmpq %rbx, %rax
jne 0x3db78
popq %rbx
popq %r14
popq %r15
retq
nop
| /aksnzhy[P]xlearn/src/reader/reader.h |
curlx_uztoul | unsigned long curlx_uztoul(size_t uznum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
#if (SIZEOF_LONG < SIZEOF_SIZE_T)
DEBUGASSERT(uznum <= (size_t) CURL_MASK_ULONG);
#endif
return (unsigned long)(uznum & (size_t) CURL_MASK_ULONG);
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $-0x1, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /devkitPro[P]curl/lib/warnless.c |
ga_put_ | void FATR ga_put_(Integer *g_a, Integer *ilo, Integer *ihi,
Integer *jlo, Integer *jhi, void *buf, Integer *ld)
{
Integer lo[2], hi[2];
lo[0]=*ilo;
lo[1]=*jlo;
hi[0]=*ihi;
hi[1]=*jhi;
wnga_put(*g_a, lo, hi, buf, ld);
} | subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
movq 0x28(%rsp), %rcx
movq 0x60(%rsp), %r8
callq 0xd8820
addq $0x58, %rsp
retq
nop
| /GlobalArrays[P]ga/global/src/fapi.c |
nga_sadd_patch_ | void FATR nga_sadd_patch_(Real *alpha, Integer *g_a, Integer *alo, Integer *ahi, Real *beta, Integer *g_b, Integer *blo, Integer *bhi, Integer *g_c, Integer *clo, Integer *chi)
{
Integer atype, btype, ctype;
pnga_inquire_type(*g_a, &atype);
pnga_inquire_type(*g_b, &btype);
pnga_inquire_type(*g_c, &ctype);
if (atype != btype || atype != ctype || atype != C_FLOAT)
pnga_error(" wrong types ", 0L);
wnga_add_patch(alpha, *g_a, alo, ahi, beta, *g_b, blo, bhi, *g_c, clo, chi);
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
leaq 0x40(%rsp), %rsi
callq 0xcebf0
movq 0x48(%rsp), %rax
movq (%rax), %rdi
leaq 0x38(%rsp), %rsi
callq 0xcebf0
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
leaq 0x30(%rsp), %rsi
callq 0xcebf0
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0xcb89
movq 0x40(%rsp), %rax
cmpq 0x30(%rsp), %rax
jne 0xcb89
cmpq $0x3eb, 0x40(%rsp) # imm = 0x3EB
je 0xcb99
leaq 0x16080e(%rip), %rdi # 0x16d39e
xorl %eax, %eax
movl %eax, %esi
callq 0x2f8f0
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rax
movq (%rax), %rsi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %rax
movq (%rax), %r9
movq 0x90(%rsp), %r14
movq 0x98(%rsp), %rbx
movq 0xa0(%rsp), %rax
movq (%rax), %r11
movq 0xa8(%rsp), %r10
movq 0xb0(%rsp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x298e0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
| /GlobalArrays[P]ga/global/src/fapi.c |
nga_zadd_patch_ | void FATR nga_zadd_patch_(DoubleComplex *alpha, Integer *g_a, Integer *alo, Integer *ahi, DoubleComplex *beta, Integer *g_b, Integer *blo, Integer *bhi, Integer *g_c, Integer *clo, Integer *chi)
{
Integer atype, btype, ctype;
pnga_inquire_type(*g_a, &atype);
pnga_inquire_type(*g_b, &btype);
pnga_inquire_type(*g_c, &ctype);
if (atype != btype || atype != ctype || atype != C_DCPL)
pnga_error(" wrong types ", 0L);
wnga_add_patch(alpha, *g_a, alo, ahi, beta, *g_b, blo, bhi, *g_c, clo, chi);
} | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
leaq 0x40(%rsp), %rsi
callq 0xcebf0
movq 0x48(%rsp), %rax
movq (%rax), %rdi
leaq 0x38(%rsp), %rsi
callq 0xcebf0
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
leaq 0x30(%rsp), %rsi
callq 0xcebf0
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0xccb9
movq 0x40(%rsp), %rax
cmpq 0x30(%rsp), %rax
jne 0xccb9
cmpq $0x3ef, 0x40(%rsp) # imm = 0x3EF
je 0xccc9
leaq 0x1606de(%rip), %rdi # 0x16d39e
xorl %eax, %eax
movl %eax, %esi
callq 0x2f8f0
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rax
movq (%rax), %rsi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %rax
movq (%rax), %r9
movq 0x90(%rsp), %r14
movq 0x98(%rsp), %rbx
movq 0xa0(%rsp), %rax
movq (%rax), %r11
movq 0xa8(%rsp), %r10
movq 0xb0(%rsp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x298e0
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
| /GlobalArrays[P]ga/global/src/fapi.c |
pnga_elem_divide | void pnga_elem_divide(Integer g_a, Integer g_b, Integer g_c){
Integer atype, andim;
Integer btype, bndim;
Integer ctype, cndim;
Integer alo[MAXDIM],ahi[MAXDIM];
Integer blo[MAXDIM],bhi[MAXDIM];
Integer clo[MAXDIM],chi[MAXDIM];
pnga_inquire(g_a, &atype, &andim, ahi);
pnga_inquire(g_b, &btype, &bndim, bhi);
pnga_inquire(g_c, &ctype, &cndim, chi);
if((andim!=bndim)||(andim!=cndim))
pnga_error("global arrays have different dimmensions.", andim);
while(andim){
alo[andim-1]=1;
blo[bndim-1]=1;
clo[cndim-1]=1;
andim--;
bndim--;
cndim--;
}
_ga_sync_begin = 1; /*just to be on the safe side*/
ngai_elem2_patch_(g_a, alo, ahi, g_b, blo, bhi,g_c,clo,chi,OP_ELEM_DIV);
} | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1e0(%rsp), %rdi
leaq 0x120(%rsp), %rcx
leaq 0x1c8(%rsp), %rsi
leaq 0x1c0(%rsp), %rdx
callq 0xcea30
movq 0x1d8(%rsp), %rdi
leaq 0xa0(%rsp), %rcx
leaq 0x1b8(%rsp), %rsi
leaq 0x1b0(%rsp), %rdx
callq 0xcea30
movq 0x1d0(%rsp), %rdi
leaq 0x20(%rsp), %rcx
leaq 0x1a8(%rsp), %rsi
leaq 0x1a0(%rsp), %rdx
callq 0xcea30
movq 0x1c0(%rsp), %rax
cmpq 0x1b0(%rsp), %rax
jne 0x1263f
movq 0x1c0(%rsp), %rax
cmpq 0x1a0(%rsp), %rax
je 0x12653
movq 0x1c0(%rsp), %rsi
leaq 0x15b192(%rip), %rdi # 0x16d7e0
callq 0x2f8f0
jmp 0x12655
cmpq $0x0, 0x1c0(%rsp)
je 0x126ea
movq 0x1c0(%rsp), %rax
subq $0x1, %rax
movq $0x1, 0x160(%rsp,%rax,8)
movq 0x1b0(%rsp), %rax
subq $0x1, %rax
movq $0x1, 0xe0(%rsp,%rax,8)
movq 0x1a0(%rsp), %rax
subq $0x1, %rax
movq $0x1, 0x60(%rsp,%rax,8)
movq 0x1c0(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x1c0(%rsp)
movq 0x1b0(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x1b0(%rsp)
movq 0x1a0(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x1a0(%rsp)
jmp 0x12655
leaq 0x17ac0f(%rip), %rax # 0x18d300
movl $0x1, (%rax)
movq 0x1e0(%rsp), %rdi
leaq 0x160(%rsp), %rsi
leaq 0x120(%rsp), %rdx
movq 0x1d8(%rsp), %rcx
leaq 0xe0(%rsp), %r8
leaq 0xa0(%rsp), %r9
movq 0x1d0(%rsp), %r11
leaq 0x60(%rsp), %r10
leaq 0x20(%rsp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x4, 0x18(%rsp)
callq 0x11350
addq $0x1e8, %rsp # imm = 0x1E8
retq
nopl (%rax)
| /GlobalArrays[P]ga/global/src/elem_alg.c |
pnga_step_max_patch | void pnga_step_max_patch(g_a, alo, ahi, g_b, blo, bhi, result)
Integer g_a, *alo, *ahi; /* patch of g_a */
Integer g_b, *blo, *bhi; /* patch of g_b */
void *result;
#if 0
Integer op; /* operations */
#endif
{
double dresult;
long lresult;
Integer atype;
Integer andim, adims[MAXDIM];
Integer btype;
Integer bndim, bdims[MAXDIM];
Integer index[MAXDIM];
/* Integer num_blocks_a, num_blocks_b; */
/* double result = -1; */
Integer g_c;
int iresult;
Integer atotal,btotal;
float fresult;
int local_sync_begin,local_sync_end;
int i;
Integer compatible;
void *sresult = NULL;
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_sync();
/* Check for valid ga handles. */
pnga_check_handle(g_a, "ga_step_max_patch_");
pnga_check_handle(g_b, "ga_step_max_patch_");
/* get chacteristics of the input ga patches */
pnga_inquire(g_a, &atype, &andim, adims);
pnga_inquire(g_b, &btype, &bndim, bdims);
/* num_blocks_a = pnga_total_blocks(g_a); */
/* num_blocks_b = pnga_total_blocks(g_b); */
/* Check for matching types. */
if(atype != btype) pnga_error(" ga_step_max_patch_: types mismatch ", 0L);
/* check if patch indices and dims match */
for(i=0; i<andim; i++)
if(alo[i] <= 0 || ahi[i] > adims[i])
pnga_error("g_a indices out of range ", g_a);
for(i=0; i<bndim; i++)
if(blo[i] <= 0 || bhi[i] > bdims[i])
pnga_error("g_b indices out of range ", g_b);
/* check if numbers of elements in patches match each other */
atotal = 1; for(i=0; i<andim; i++) atotal *= (ahi[i] - alo[i] + 1);
btotal = 1; for(i=0; i<bndim; i++) btotal *= (bhi[i] - blo[i] + 1);
if(btotal != atotal)
pnga_error(" ga_step_max_patch_ capacities of patches do not match ", 0L);
/* test if patches match */
if(pnga_comp_patch(andim, alo, ahi, bndim, blo, bhi)) compatible = 1;
else compatible = 0;
/* pnga_gop(pnga_type_f2c(MT_F_INT), &compatible, 1, "*"); */
pnga_gop(pnga_type_f2c(MT_F_INT), &compatible, 1, "&&");
if(!compatible) {
pnga_error(" ga_step_max_patch_ mismatched patchs ",0);
}
switch (atype)
{
case C_INT:
sresult = &iresult;
break;
case C_DCPL:
case C_SCPL:
pnga_error("Ga_step_max_patch_: unavalable for complex datatype.",
atype);
break;
case C_DBL:
sresult = &dresult;
break;
case C_FLOAT:
sresult = &fresult;
break;
case C_LONG:
sresult = &lresult;
break;
default:
pnga_error("Ga_step_max_patch_: wrong data type.", atype);
}
if(g_a == g_b) {
/* It used to say 1, but if ga and gb are the same, and
ga is nonnegative then any number of multiples of gb
can be added to ga still leaving it nonnegative.
*result = (double)1.0;
*/
switch (atype)
{
case C_INT:
*(int*)result = GA_INFINITY_I;
break;
case C_DCPL:
case C_SCPL:
pnga_error("Ga_step_max_patch_: unavailable for complex datatype.",
atype);
break;
case C_DBL:
*(double*)result = GA_INFINITY_D;
break;
case C_FLOAT:
*(float*)result = GA_INFINITY_F;
break;
case C_LONG:
*(long*)result = GA_INFINITY_L;
break;
default:
pnga_error("Ga_step_max_patch_: wrong data type.", atype);
}
} else {
/*Now look at each element of the array g_a.
If an element of g_a is negative, then simply return */
if(has_negative_elem(g_a, alo, ahi) == 1)
pnga_error("ga_step_max_patch_: g_a has negative element.", -1);
/*duplicate an array c to hold the temparate result = g_a/g_b; */
pnga_duplicate(g_a, &g_c, "Temp");
if(g_c==0)
pnga_error("ga_step_max_patch_:fail to duplicate array c", g_a);
/*
pnga_elem_divide_patch(g_a, alo, ahi, g_b, blo, bhi, g_c, alo, ahi);
*/
pnga_elem_step_divide_patch(g_a, alo, ahi, g_b, blo, bhi,
g_c, alo, ahi);
/*Now look at each element of the array g_c. If an element of g_c is positive,
then replace it with -GA_INFINITY */
ngai_elem3_patch_(g_c, alo, ahi, OP_STEPMAX);
/*Then, we will select the maximum of the array g_c*/
pnga_select_elem(g_c, "max", sresult, index);
switch (atype)
{
case C_INT:
*(int*)result = GA_ABS(iresult);
break;
case C_DCPL:
case C_SCPL:
pnga_error("Ga_step_max_patch_: unavailable for complex datatype.",
atype);
break;
case C_DBL:
*(double*)result = GA_ABS(dresult);
break;
case C_FLOAT:
*(float*)result = GA_ABS(fresult);
break;
case C_LONG:
*(long*)result = GA_ABS(lresult);
break;
default:
pnga_error("Ga_step_max_patch_: wrong data type.", atype);
}
pnga_destroy(g_c);
}
if(local_sync_end)pnga_sync();
} | subq $0x1a8, %rsp # imm = 0x1A8
movq 0x1b0(%rsp), %rax
movq %rdi, 0x1a0(%rsp)
movq %rsi, 0x198(%rsp)
movq %rdx, 0x190(%rsp)
movq %rcx, 0x188(%rsp)
movq %r8, 0x180(%rsp)
movq %r9, 0x178(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x178a21(%rip), %rax # 0x18d300
movl (%rax), %eax
movl %eax, 0x68(%rsp)
leaq 0x178a18(%rip), %rax # 0x18d304
movl (%rax), %eax
movl %eax, 0x64(%rsp)
leaq 0x178a07(%rip), %rax # 0x18d300
movl $0x1, (%rax)
leaq 0x1789fe(%rip), %rax # 0x18d304
movl $0x1, (%rax)
cmpl $0x0, 0x68(%rsp)
je 0x1491a
movb $0x0, %al
callq 0xd7290
movq 0x1a0(%rsp), %rdi
leaq 0x15920b(%rip), %rsi # 0x16db34
callq 0xb8750
movq 0x188(%rsp), %rdi
leaq 0x1591f7(%rip), %rsi # 0x16db34
callq 0xb8750
movq 0x1a0(%rsp), %rdi
leaq 0x120(%rsp), %rcx
leaq 0x160(%rsp), %rsi
leaq 0x158(%rsp), %rdx
callq 0xcea30
movq 0x188(%rsp), %rdi
leaq 0xd0(%rsp), %rcx
leaq 0x118(%rsp), %rsi
leaq 0x110(%rsp), %rdx
callq 0xcea30
movq 0x160(%rsp), %rax
cmpq 0x118(%rsp), %rax
je 0x149ae
leaq 0x1591a2(%rip), %rdi # 0x16db47
xorl %eax, %eax
movl %eax, %esi
callq 0x2f8f0
movl $0x0, 0x60(%rsp)
movslq 0x60(%rsp), %rax
cmpq 0x158(%rsp), %rax
jge 0x14a1c
movq 0x198(%rsp), %rax
movslq 0x60(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jle 0x149f9
movq 0x190(%rsp), %rax
movslq 0x60(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x60(%rsp), %rcx
cmpq 0x120(%rsp,%rcx,8), %rax
jle 0x14a0d
movq 0x1a0(%rsp), %rsi
leaq 0x15ac7c(%rip), %rdi # 0x16f684
callq 0x2f8f0
jmp 0x14a0f
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x149b6
movl $0x0, 0x60(%rsp)
movslq 0x60(%rsp), %rax
cmpq 0x110(%rsp), %rax
jge 0x14a8a
movq 0x180(%rsp), %rax
movslq 0x60(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jle 0x14a67
movq 0x178(%rsp), %rax
movslq 0x60(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x60(%rsp), %rcx
cmpq 0xd0(%rsp,%rcx,8), %rax
jle 0x14a7b
movq 0x188(%rsp), %rsi
leaq 0x15ac2a(%rip), %rdi # 0x16f6a0
callq 0x2f8f0
jmp 0x14a7d
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x14a24
movq $0x1, 0x78(%rsp)
movl $0x0, 0x60(%rsp)
movslq 0x60(%rsp), %rax
cmpq 0x158(%rsp), %rax
jge 0x14ae8
movq 0x190(%rsp), %rax
movslq 0x60(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x198(%rsp), %rcx
movslq 0x60(%rsp), %rdx
subq (%rcx,%rdx,8), %rax
addq $0x1, %rax
imulq 0x78(%rsp), %rax
movq %rax, 0x78(%rsp)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x14a9b
movq $0x1, 0x70(%rsp)
movl $0x0, 0x60(%rsp)
movslq 0x60(%rsp), %rax
cmpq 0x110(%rsp), %rax
jge 0x14b46
movq 0x178(%rsp), %rax
movslq 0x60(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x180(%rsp), %rcx
movslq 0x60(%rsp), %rdx
subq (%rcx,%rdx,8), %rax
addq $0x1, %rax
imulq 0x70(%rsp), %rax
movq %rax, 0x70(%rsp)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x14af9
movq 0x70(%rsp), %rax
cmpq 0x78(%rsp), %rax
je 0x14b62
leaq 0x159013(%rip), %rdi # 0x16db6c
xorl %eax, %eax
movl %eax, %esi
callq 0x2f8f0
movq 0x158(%rsp), %rdi
movq 0x198(%rsp), %rsi
movq 0x190(%rsp), %rdx
movq 0x110(%rsp), %rcx
movq 0x180(%rsp), %r8
movq 0x178(%rsp), %r9
callq 0x22150
cmpq $0x0, %rax
je 0x14ba8
movq $0x1, 0x58(%rsp)
jmp 0x14bb1
movq $0x0, 0x58(%rsp)
movl $0x3f2, %edi # imm = 0x3F2
callq 0xfa00
movq %rax, %rdi
leaq 0x58(%rsp), %rsi
movl $0x1, %edx
leaq 0x158cfc(%rip), %rcx # 0x16d8cb
callq 0xfc950
cmpq $0x0, 0x58(%rsp)
jne 0x14bec
leaq 0x158fc1(%rip), %rdi # 0x16dba4
xorl %eax, %eax
movl %eax, %esi
callq 0x2f8f0
movq 0x160(%rsp), %rax
addq $-0x3e9, %rax # imm = 0xFC17
movq %rax, 0x48(%rsp)
subq $0x6, %rax
ja 0x14c69
movq 0x48(%rsp), %rax
leaq 0x15891b(%rip), %rcx # 0x16d52c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x84(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x14c7d
movq 0x160(%rsp), %rsi
leaq 0x158f93(%rip), %rdi # 0x16dbcb
callq 0x2f8f0
jmp 0x14c7d
leaq 0x170(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x14c7d
leaq 0x6c(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x14c7d
leaq 0x168(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x14c7d
movq 0x160(%rsp), %rsi
leaq 0x158f88(%rip), %rdi # 0x16dc00
callq 0x2f8f0
movq 0x1a0(%rsp), %rax
cmpq 0x188(%rsp), %rax
jne 0x14d43
movq 0x160(%rsp), %rax
addq $-0x3e9, %rax # imm = 0xFC17
movq %rax, 0x40(%rsp)
subq $0x6, %rax
ja 0x14d2a
movq 0x40(%rsp), %rax
leaq 0x1588ac(%rip), %rcx # 0x16d564
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x1b0(%rsp), %rax
movl $0x7fffffff, (%rax) # imm = 0x7FFFFFFF
jmp 0x14d3e
movq 0x160(%rsp), %rsi
leaq 0x158f45(%rip), %rdi # 0x16dc25
callq 0x2f8f0
jmp 0x14d3e
movq 0x1b0(%rsp), %rax
movsd 0x158ad1(%rip), %xmm0 # 0x16d7c8
movsd %xmm0, (%rax)
jmp 0x14d3e
movq 0x1b0(%rsp), %rax
movss 0x158a9f(%rip), %xmm0 # 0x16d7ac
movss %xmm0, (%rax)
jmp 0x14d3e
movq 0x1b0(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, (%rax)
jmp 0x14d3e
movq 0x160(%rsp), %rsi
leaq 0x158ec7(%rip), %rdi # 0x16dc00
callq 0x2f8f0
jmp 0x14fc9
movq 0x1a0(%rsp), %rdi
movq 0x198(%rsp), %rsi
movq 0x190(%rsp), %rdx
callq 0x14440
cmpq $0x1, %rax
jne 0x14d79
leaq 0x158eee(%rip), %rdi # 0x16dc5b
movq $-0x1, %rsi
callq 0x2f8f0
movq 0x1a0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x158ef9(%rip), %rdx # 0x16dc89
callq 0xcbd80
cmpq $0x0, 0x88(%rsp)
jne 0x14db4
movq 0x1a0(%rsp), %rsi
leaq 0x158edf(%rip), %rdi # 0x16dc8e
callq 0x2f8f0
movq 0x1a0(%rsp), %rdi
movq 0x198(%rsp), %rsi
movq 0x190(%rsp), %rdx
movq 0x188(%rsp), %rcx
movq 0x180(%rsp), %r8
movq 0x178(%rsp), %r9
movq 0x88(%rsp), %r10
movq %rsp, %rax
movq %rdx, 0x10(%rax)
movq %rsi, 0x8(%rax)
movq %r10, (%rax)
callq 0x12c00
movq 0x88(%rsp), %rdi
movq 0x198(%rsp), %rsi
movq 0x190(%rsp), %rdx
movl $0x7, %ecx
callq 0x14fe0
movq 0x88(%rsp), %rdi
movq 0x50(%rsp), %rdx
leaq 0x15f81f(%rip), %rsi # 0x174654
leaq 0x90(%rsp), %rcx
callq 0x53d00
movq 0x160(%rsp), %rax
addq $-0x3e9, %rax # imm = 0xFC17
movq %rax, 0x38(%rsp)
subq $0x6, %rax
ja 0x14fa8
movq 0x38(%rsp), %rax
leaq 0x1586dd(%rip), %rcx # 0x16d548
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0x84(%rsp)
jl 0x14e8b
movl 0x84(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x14e98
xorl %eax, %eax
subl 0x84(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %ecx
movq 0x1b0(%rsp), %rax
movl %ecx, (%rax)
jmp 0x14fbc
movq 0x160(%rsp), %rsi
leaq 0x158d6b(%rip), %rdi # 0x16dc25
callq 0x2f8f0
jmp 0x14fbc
movsd 0x170(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x14ee7
movsd 0x170(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
jmp 0x14f0d
movsd 0x170(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x1b0(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x14fbc
movss 0x6c(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x14f40
movss 0x6c(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x14f59
movss 0x6c(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x24(%rsp), %xmm0
movq 0x1b0(%rsp), %rax
movss %xmm0, (%rax)
jmp 0x14fbc
cmpq $0x0, 0x168(%rsp)
jl 0x14f87
movq 0x168(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x14f96
xorl %eax, %eax
subq 0x168(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x1b0(%rsp), %rax
movq %rcx, (%rax)
jmp 0x14fbc
movq 0x160(%rsp), %rsi
leaq 0x158c49(%rip), %rdi # 0x16dc00
callq 0x2f8f0
movq 0x88(%rsp), %rdi
callq 0xc69d0
cmpl $0x0, 0x64(%rsp)
je 0x14fd7
movb $0x0, %al
callq 0xd7290
addq $0x1a8, %rsp # imm = 0x1A8
retq
nop
| /GlobalArrays[P]ga/global/src/elem_alg.c |
ngai_elem3_patch_ | static void ngai_elem3_patch_(Integer g_a, Integer *alo, Integer *ahi, int op)
/*do some preprocess jobs for stepMax and stepMax2*/
{
Integer i;
Integer atype;
Integer andim, adims[MAXDIM];
Integer loA[MAXDIM], hiA[MAXDIM], ldA[MAXDIM];
char *A_ptr;
Integer me= pnga_nodeid();
Integer num_blocks;
int local_sync_begin,local_sync_end;
_iterator_hdl hdl;
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_sync();
pnga_check_handle(g_a, "gai_elem3_patch_");
pnga_inquire(g_a, &atype, &andim, adims);
num_blocks = pnga_total_blocks(g_a);
/* check if patch indices and dims match */
for(i=0; i<andim; i++)
if(alo[i] <= 0 || ahi[i] > adims[i])
pnga_error("g_a indices out of range ", g_a);
#if 1
pnga_local_iterator_init(g_a, &hdl);
while (pnga_local_iterator_next(&hdl, loA, hiA, &A_ptr, ldA)) {
Integer offset, j, jtmp, chk;
Integer loS[MAXDIM];
/* loA is changed by pnga_patch_intersect, so
* save a copy */
for (j=0; j<andim; j++) {
loS[j] = loA[j];
}
/* determine subset of my local patch to access */
/* Output is in loA and hiA */
if(pnga_patch_intersect(alo, ahi, loA, hiA, andim)){
/* Check for partial overlap */
chk = 1;
for (j=0; j<andim; j++) {
if (loS[j] < loA[j]) {
chk=0;
break;
}
}
if (!chk) {
/* Evaluate additional offset for pointer */
offset = 0;
jtmp = 1;
for (j=0; j<andim-1; j++) {
offset += (loA[j]-loS[j])*jtmp;
jtmp *= ldA[j];
}
offset += (loA[andim-1]-loS[andim-1])*jtmp;
switch (atype){
case C_INT:
A_ptr = (void*)((int*)A_ptr + offset);
break;
case C_DCPL:
A_ptr = (void*)((double*)A_ptr + 2*offset);
break;
case C_SCPL:
A_ptr = (void*)((float*)A_ptr + 2*offset);
break;
case C_DBL:
A_ptr = (void*)((double*)A_ptr + offset);
break;
case C_FLOAT:
A_ptr = (void*)((float*)A_ptr + offset);
break;
case C_LONG:
A_ptr = (void*)((long*)A_ptr + offset);
break;
default: pnga_error(" wrong data type ",atype);
}
}
/* compute "local" operation according to op */
ngai_do_elem3_patch(atype, andim, loA, hiA, ldA, A_ptr, op);
}
}
#else
if (num_blocks < 0) {
/* find out coordinates of patches of g_a, g_b and g_c that I own */
pnga_distribution(g_a, me, loA, hiA);
/* determine subsets of my patches to access */
if (pnga_patch_intersect(alo, ahi, loA, hiA, andim)){
pnga_access_ptr(g_a, loA, hiA, &A_ptr, ldA);
/* compute "local" operation accoording to op */
ngai_do_elem3_patch(atype, andim, loA, hiA, ldA, A_ptr, op);
/* release access to the data */
pnga_release (g_a, loA, hiA);
}
} else {
Integer offset, j, jtmp, chk;
Integer loS[MAXDIM], nproc;
nproc = pnga_nnodes();
/* using simple block-cyclic data distribution */
if (!pnga_uses_proc_grid(g_a)){
for (i=me; i<num_blocks; i += nproc) {
/* get limits of patch */
pnga_distribution(g_a, i, loA, hiA);
/* loA is changed by pnga_patch_intersect, so
* save a copy */
for (j=0; j<andim; j++) {
loS[j] = loA[j];
}
/* determine subset of my local patch to access */
/* Output is in loA and hiA */
if(pnga_patch_intersect(alo, ahi, loA, hiA, andim)){
/* get data_ptr to corner of patch */
/* ld are leading dimensions for block */
pnga_access_block_ptr(g_a, i, &A_ptr, ldA);
/* Check for partial overlap */
chk = 1;
for (j=0; j<andim; j++) {
if (loS[j] < loA[j]) {
chk=0;
break;
}
}
if (!chk) {
/* Evaluate additional offset for pointer */
offset = 0;
jtmp = 1;
for (j=0; j<andim-1; j++) {
offset += (loA[j]-loS[j])*jtmp;
jtmp *= ldA[j];
}
offset += (loA[andim-1]-loS[andim-1])*jtmp;
switch (atype){
case C_INT:
A_ptr = (void*)((int*)A_ptr + offset);
break;
case C_DCPL:
A_ptr = (void*)((double*)A_ptr + 2*offset);
break;
case C_SCPL:
A_ptr = (void*)((float*)A_ptr + 2*offset);
break;
case C_DBL:
A_ptr = (void*)((double*)A_ptr + offset);
break;
case C_FLOAT:
A_ptr = (void*)((float*)A_ptr + offset);
break;
case C_LONG:
A_ptr = (void*)((long*)A_ptr + offset);
break;
default: pnga_error(" wrong data type ",atype);
}
}
/* compute "local" operation accoording to op */
ngai_do_elem3_patch(atype, andim, loA, hiA, ldA, A_ptr, op);
/* release access to the data */
pnga_release_update_block(g_a, i);
}
}
} else {
/* using scalapack block-cyclic data distribution */
Integer proc_index[MAXDIM], index[MAXDIM];
Integer topology[MAXDIM];
Integer blocks[MAXDIM], block_dims[MAXDIM];
pnga_get_proc_index(g_a, me, proc_index);
pnga_get_proc_index(g_a, me, index);
pnga_get_block_info(g_a, blocks, block_dims);
pnga_get_proc_grid(g_a, topology);
while (index[andim-1] < blocks[andim-1]) {
/* find bounding coordinates of block */
for (i = 0; i < andim; i++) {
loA[i] = index[i]*block_dims[i]+1;
hiA[i] = (index[i] + 1)*block_dims[i];
if (hiA[i] > adims[i]) hiA[i] = adims[i];
}
/* loA is changed by pnga_patch_intersect, so
* save a copy */
for (j=0; j<andim; j++) {
loS[j] = loA[j];
}
/* determine subset of my local patch to access */
/* Output is in loA and hiA */
if(pnga_patch_intersect(alo, ahi, loA, hiA, andim)){
/* get data_ptr to corner of patch */
/* ld are leading dimensions for block */
pnga_access_block_grid_ptr(g_a, index, &A_ptr, ldA);
/* Check for partial overlap */
chk = 1;
for (j=0; j<andim; j++) {
if (loS[j] < loA[j]) {
chk=0;
break;
}
}
if (!chk) {
/* Evaluate additional offset for pointer */
offset = 0;
jtmp = 1;
for (j=0; j<andim-1; j++) {
offset += (loA[j]-loS[j])*jtmp;
jtmp *= ldA[j];
}
offset += (loA[andim-1]-loS[andim-1])*jtmp;
switch (atype){
case C_INT:
A_ptr = (void*)((int*)A_ptr + offset);
break;
case C_DCPL:
A_ptr = (void*)((double*)A_ptr + 2*offset);
break;
case C_SCPL:
A_ptr = (void*)((float*)A_ptr + 2*offset);
break;
case C_DBL:
A_ptr = (void*)((double*)A_ptr + offset);
break;
case C_FLOAT:
A_ptr = (void*)((float*)A_ptr + offset);
break;
case C_LONG:
A_ptr = (void*)((long*)A_ptr + offset);
break;
default: pnga_error(" wrong data type ",atype);
}
}
/* compute "local" operation accoording to op */
ngai_do_elem3_patch(atype, andim, loA, hiA, ldA, A_ptr, op);
/* release access to the data */
pnga_release_update_block_grid(g_a, index);
}
/* increment index to get next block on processor */
index[0] += topology[0];
for (i = 0; i < andim; i++) {
if (index[i] >= blocks[i] && i<andim-1) {
index[i] = proc_index[i];
index[i+1] += topology[i+1];
}
}
}
}
}
#endif
if(local_sync_end)pnga_sync();
} | subq $0x4c8, %rsp # imm = 0x4C8
movq %rdi, 0x4c0(%rsp)
movq %rsi, 0x4b8(%rsp)
movq %rdx, 0x4b0(%rsp)
movl %ecx, 0x4ac(%rsp)
movb $0x0, %al
callq 0xd4900
movq %rax, 0x380(%rsp)
leaq 0x1782e4(%rip), %rax # 0x18d300
movl (%rax), %eax
movl %eax, 0x374(%rsp)
leaq 0x1782d8(%rip), %rax # 0x18d304
movl (%rax), %eax
movl %eax, 0x370(%rsp)
leaq 0x1782c4(%rip), %rax # 0x18d300
movl $0x1, (%rax)
leaq 0x1782bb(%rip), %rax # 0x18d304
movl $0x1, (%rax)
cmpl $0x0, 0x374(%rsp)
je 0x15060
movb $0x0, %al
callq 0xd7290
movq 0x4c0(%rsp), %rdi
leaq 0x158e92(%rip), %rsi # 0x16df01
callq 0xb8750
movq 0x4c0(%rsp), %rdi
leaq 0x450(%rsp), %rcx
leaq 0x498(%rsp), %rsi
leaq 0x490(%rsp), %rdx
callq 0xcea30
movq 0x4c0(%rsp), %rdi
callq 0xd67d0
movq %rax, 0x378(%rsp)
movq $0x0, 0x4a0(%rsp)
movq 0x4a0(%rsp), %rax
cmpq 0x490(%rsp), %rax
jge 0x15135
movq 0x4b8(%rsp), %rax
movq 0x4a0(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jle 0x15109
movq 0x4b0(%rsp), %rax
movq 0x4a0(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x4a0(%rsp), %rcx
cmpq 0x450(%rsp,%rcx,8), %rax
jle 0x1511d
movq 0x4c0(%rsp), %rsi
leaq 0x15a56c(%rip), %rdi # 0x16f684
callq 0x2f8f0
jmp 0x1511f
movq 0x4a0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x4a0(%rsp)
jmp 0x150ba
movq 0x4c0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x3cba0
leaq 0x410(%rsp), %rsi
leaq 0x3d0(%rsp), %rdx
leaq 0x390(%rsp), %r8
leaq 0x70(%rsp), %rdi
leaq 0x388(%rsp), %rcx
callq 0x3d800
cmpl $0x0, %eax
je 0x1544f
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x490(%rsp), %rax
jge 0x151b9
movq 0x60(%rsp), %rax
movq 0x410(%rsp,%rax,8), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x10(%rsp,%rax,8)
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x15183
movq 0x4b8(%rsp), %rdi
movq 0x4b0(%rsp), %rsi
leaq 0x410(%rsp), %rdx
leaq 0x3d0(%rsp), %rcx
movq 0x490(%rsp), %r8
callq 0x21f40
cmpq $0x0, %rax
je 0x1544a
movq $0x1, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
cmpq 0x490(%rsp), %rax
jge 0x15247
movq 0x60(%rsp), %rax
movq 0x10(%rsp,%rax,8), %rax
movq 0x60(%rsp), %rcx
cmpq 0x410(%rsp,%rcx,8), %rax
jge 0x15235
movq $0x0, 0x50(%rsp)
jmp 0x15247
jmp 0x15237
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x15202
cmpq $0x0, 0x50(%rsp)
jne 0x15409
movq $0x0, 0x68(%rsp)
movq $0x1, 0x58(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x490(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x152d3
movq 0x60(%rsp), %rax
movq 0x410(%rsp,%rax,8), %rax
movq 0x60(%rsp), %rcx
subq 0x10(%rsp,%rcx,8), %rax
imulq 0x58(%rsp), %rax
addq 0x68(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq 0x390(%rsp,%rax,8), %rax
imulq 0x58(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x1526e
movq 0x490(%rsp), %rax
movq 0x408(%rsp,%rax,8), %rcx
movq 0x8(%rsp,%rax,8), %rax
subq %rax, %rcx
movq 0x58(%rsp), %rax
imulq %rax, %rcx
movq 0x68(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x498(%rsp), %rax
addq $-0x3e9, %rax # imm = 0xFC17
movq %rax, 0x8(%rsp)
subq $0x6, %rax
ja 0x153f3
movq 0x8(%rsp), %rax
leaq 0x158256(%rip), %rcx # 0x16d580
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x388(%rsp), %rax
movq 0x68(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x388(%rsp)
jmp 0x15407
movq 0x388(%rsp), %rax
movq 0x68(%rsp), %rcx
shlq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x388(%rsp)
jmp 0x15407
movq 0x388(%rsp), %rax
movq 0x68(%rsp), %rcx
shlq %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x388(%rsp)
jmp 0x15407
movq 0x388(%rsp), %rax
movq 0x68(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x388(%rsp)
jmp 0x15407
movq 0x388(%rsp), %rax
movq 0x68(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x388(%rsp)
jmp 0x15407
movq 0x388(%rsp), %rax
movq 0x68(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x388(%rsp)
jmp 0x15407
movq 0x498(%rsp), %rsi
leaq 0x15ab46(%rip), %rdi # 0x16ff48
callq 0x2f8f0
jmp 0x15409
movq 0x498(%rsp), %rdi
movq 0x490(%rsp), %rsi
leaq 0x410(%rsp), %rdx
leaq 0x3d0(%rsp), %rcx
leaq 0x390(%rsp), %r8
movq 0x388(%rsp), %r9
movslq 0x4ac(%rsp), %rax
movq %rax, (%rsp)
callq 0x1b880
jmp 0x15147
cmpl $0x0, 0x370(%rsp)
je 0x15460
movb $0x0, %al
callq 0xd7290
addq $0x4c8, %rsp # imm = 0x4C8
retq
nopl (%rax,%rax)
| /GlobalArrays[P]ga/global/src/elem_alg.c |
ma_table_verify | public Boolean ma_table_verify(handle, caller)
Integer handle; /* to verify */
char *caller; /* name of calling routine */
{
Boolean badhandle; /* is handle invalid? */
badhandle = MA_FALSE;
/* if handle is invalid, construct an error message */
if ((handle < 0) ||
(handle >= ma_table_capacity) ||
(ma_table[handle].state == TES_Unused))
{
(void)sprintf(ma_ebuf,
"handle %ld is not valid",
(long)handle);
badhandle = MA_TRUE;
}
else if (ma_table[handle].state == TES_Deallocated)
{
(void)sprintf(ma_ebuf,
"handle %ld already deallocated",
(long)handle);
badhandle = MA_TRUE;
}
if (badhandle)
{
/* invalid handle */
ma_error(EL_Nonfatal, ET_External, caller, ma_ebuf);
return MA_FALSE;
}
else
/* valid handle */
return MA_TRUE;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jl 0xad476
movq 0x18(%rsp), %rax
cmpq 0xe54ed(%rip), %rax # 0x192948
jge 0xad476
movq 0xe54ec(%rip), %rax # 0x192950
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0xad49b
movq 0x18(%rsp), %rdx
leaq 0xe50be(%rip), %rdi # 0x192540
leaq 0xc6737(%rip), %rsi # 0x173bc0
movb $0x0, %al
callq 0x3090
movq $0x1, 0x8(%rsp)
jmp 0xad4d9
movq 0xe54ae(%rip), %rax # 0x192950
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x2, 0x8(%rax)
jne 0xad4d7
movq 0x18(%rsp), %rdx
leaq 0xe5080(%rip), %rdi # 0x192540
leaq 0xc6711(%rip), %rsi # 0x173bd8
movb $0x0, %al
callq 0x3090
movq $0x1, 0x8(%rsp)
jmp 0xad4d9
cmpq $0x0, 0x8(%rsp)
je 0xad504
movq 0x10(%rsp), %rdx
movl $0x1, %edi
xorl %esi, %esi
leaq 0xe504c(%rip), %rcx # 0x192540
callq 0xad030
movq $0x0, 0x20(%rsp)
jmp 0xad50d
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| /GlobalArrays[P]ga/ma/table.c |
ga_f2c_get_cmd_args | void ga_f2c_get_cmd_args(int *argc, char ***argv)
{
Integer i=0;
int iargc=F2C_IARGC();
char **iargv=NULL;
if (iargc > F2C_GETARG_ARGV_MAX) {
printf("ga_f2c_get_cmd_args: too many cmd line args");
armci_msg_abort(1);
}
iargv = (char**)malloc(sizeof(char*)*F2C_GETARG_ARGV_MAX);
if (!iargv) {
printf("ga_f2c_get_cmd_args: malloc iargv failed");
armci_msg_abort(1);
}
for (i=0; i<iargc; i++) {
char fstring[F2C_GETARG_ARGLEN_MAX];
char cstring[F2C_GETARG_ARGLEN_MAX];
F2C_GETARG(&i, fstring, F2C_GETARG_ARGLEN_MAX);
ga_f2cstring(fstring, F2C_GETARG_ARGLEN_MAX,
cstring, F2C_GETARG_ARGLEN_MAX);
iargv[i] = strdup(cstring);
}
*argc = iargc;
*argv = iargv;
iargv[iargc] = 0;
} | subq $0x228, %rsp # imm = 0x228
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq $0x0, 0x210(%rsp)
movb $0x0, %al
callq 0xade50
movl %eax, 0x20c(%rsp)
movq $0x0, 0x200(%rsp)
cmpl $0xff, 0x20c(%rsp)
jle 0xadd42
leaq 0xc5ec6(%rip), %rdi # 0x173bf7
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0xb2080
movl $0x7f8, %edi # imm = 0x7F8
callq 0x3370
movq %rax, 0x200(%rsp)
cmpq $0x0, 0x200(%rsp)
jne 0xadd77
leaq 0xc5ebd(%rip), %rdi # 0x173c23
movb $0x0, %al
callq 0x3050
movl $0x1, %edi
callq 0xb2080
movq $0x0, 0x210(%rsp)
movq 0x210(%rsp), %rax
movslq 0x20c(%rsp), %rcx
cmpq %rcx, %rax
jge 0xaddfe
leaq 0x100(%rsp), %rsi
leaq 0x210(%rsp), %rdi
movl $0xff, %edx
callq 0xade70
leaq 0x100(%rsp), %rdi
movq %rsp, %rdx
movl $0xff, %ecx
movl %ecx, %esi
callq 0xadc30
movq %rsp, %rdi
callq 0x34a0
movq %rax, %rdx
movq 0x200(%rsp), %rax
movq 0x210(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x210(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x210(%rsp)
jmp 0xadd83
movl 0x20c(%rsp), %ecx
movq 0x220(%rsp), %rax
movl %ecx, (%rax)
movq 0x200(%rsp), %rcx
movq 0x218(%rsp), %rax
movq %rcx, (%rax)
movq 0x200(%rsp), %rax
movslq 0x20c(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x228, %rsp # imm = 0x228
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /GlobalArrays[P]ga/gaf2c/gaf2c.c |
PARMCI_Memget | void PARMCI_Memget(size_t bytes, armci_meminfo_t *meminfo, int memflg)
{
void *myptr=NULL;
void *armci_ptr=NULL; /* legal ARCMI ptr used in ARMCI data xfer ops*/
size_t size = bytes;
int rank;
comex_group_rank(COMEX_GROUP_WORLD, &rank);
if(size<=0) comex_error("PARMCI_Memget: size must be > 0", (int)size);
if(meminfo==NULL) comex_error("PARMCI_Memget: Invalid arg #2 (NULL ptr)",0);
if(memflg!=0) comex_error("PARMCI_Memget: Invalid memflg", memflg);
armci_ptr = myptr = comex_malloc_local(size);
if(size) if(!myptr) comex_error("PARMCI_Memget failed", (int)size);
/* fill the meminfo structure */
meminfo->armci_addr = armci_ptr;
meminfo->addr = myptr;
meminfo->size = size;
meminfo->cpid = rank;
/* meminfo->attr = NULL; */
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %edi, %edi
leaq 0x4(%rsp), %rsi
callq 0xb7e90
cmpq $0x0, 0x8(%rsp)
ja 0xaf055
movq 0x8(%rsp), %rax
movl %eax, %esi
leaq 0xc4e16(%rip), %rdi # 0x173e66
callq 0xb5fe0
cmpq $0x0, 0x28(%rsp)
jne 0xaf06b
leaq 0xc4e22(%rip), %rdi # 0x173e86
xorl %esi, %esi
callq 0xb5fe0
cmpl $0x0, 0x24(%rsp)
je 0xaf082
movl 0x24(%rsp), %esi
leaq 0xc4e32(%rip), %rdi # 0x173eaf
callq 0xb5fe0
movq 0x8(%rsp), %rdi
callq 0xb6040
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xaf0bb
cmpq $0x0, 0x18(%rsp)
jne 0xaf0b9
movq 0x8(%rsp), %rax
movl %eax, %esi
leaq 0xc4e19(%rip), %rdi # 0x173ecd
callq 0xb5fe0
jmp 0xaf0bb
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x4(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| /GlobalArrays[P]ga/comex/src-armci/armci.c |
comex_get_igroup_from_group | comex_igroup_t* comex_get_igroup_from_group(comex_group_t id)
{
comex_igroup_t *current_group_list_item = group_list;
assert(group_list != NULL);
while (current_group_list_item != NULL) {
if (current_group_list_item->id == id) {
return current_group_list_item;
}
current_group_list_item = current_group_list_item->next;
}
comex_error("comex group lookup failed", -1);
return NULL;
} | subq $0x18, %rsp
movl %edi, 0xc(%rsp)
leaq 0xdac01(%rip), %rax # 0x192a00
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0xdabf3(%rip), %rax # 0x192a00
cmpq $0x0, (%rax)
je 0xb7e15
jmp 0xb7e34
leaq 0xbd5b9(%rip), %rdi # 0x1753d5
leaq 0xbd5c5(%rip), %rsi # 0x1753e8
movl $0x22, %edx
leaq 0xbd614(%rip), %rcx # 0x175443
callq 0x3170
jmp 0xb7e36
cmpq $0x0, (%rsp)
je 0xb7e62
movq (%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0xc(%rsp), %eax
jne 0xb7e55
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xb7e7c
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0xb7e36
leaq 0xbd615(%rip), %rdi # 0x17547e
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xb5fe0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /GlobalArrays[P]ga/comex/src-mpi/groups.c |
GAsizeof | Integer GAsizeof(Integer type)
{
switch (type) {
case C_DBL : return (sizeof(double));
case C_INT : return (sizeof(int));
case C_SCPL : return (sizeof(SingleComplex));
case C_DCPL : return (sizeof(DoubleComplex));
case C_FLOAT : return (sizeof(float));
case C_LONG : return (sizeof(long));
case C_LONGLONG : return (sizeof(long long));
case F_DBL : return (sizeof(DoublePrecision));
case F_INT : return (sizeof(Integer));
default : return 0;
}
} | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
addq $-0x3e9, %rax # imm = 0xFC17
movq %rax, -0x18(%rsp)
subq $0xf, %rax
ja 0xb86b3
movq -0x18(%rsp), %rax
leaq 0xbcfdd(%rip), %rcx # 0x175624
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x8, -0x8(%rsp)
jmp 0xb86bc
movq $0x4, -0x8(%rsp)
jmp 0xb86bc
movq $0x8, -0x8(%rsp)
jmp 0xb86bc
movq $0x10, -0x8(%rsp)
jmp 0xb86bc
movq $0x4, -0x8(%rsp)
jmp 0xb86bc
movq $0x8, -0x8(%rsp)
jmp 0xb86bc
movq $0x8, -0x8(%rsp)
jmp 0xb86bc
movq $0x8, -0x8(%rsp)
jmp 0xb86bc
movq $0x8, -0x8(%rsp)
jmp 0xb86bc
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
| /GlobalArrays[P]ga/global/src/base.c |
pnga_proc_topology | void pnga_proc_topology(Integer g_a, Integer proc, Integer* subscript)
{
Integer d, index, ndim, ga_handle = GA_OFFSET + g_a;
ga_check_handleM(g_a, "nga_proc_topology");
ndim = GA[ga_handle].ndim;
index = proc;
for(d=0; d<ndim; d++){
subscript[d] = index% GA[ga_handle].nblock[d];
index /= GA[ga_handle].nblock[d];
}
} | subq $0x238, %rsp # imm = 0x238
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq %rdx, 0x220(%rsp)
movq 0x230(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x200(%rsp)
movq 0x230(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
cmpq $0x0, %rax
jl 0xbdbe6
movq 0x230(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
leaq 0xcf72a(%rip), %rcx # 0x18d308
movslq (%rcx), %rcx
cmpq %rcx, %rax
jl 0xbdc18
leaq 0x100(%rsp), %rdi
leaq 0xb7beb(%rip), %rsi # 0x1757e0
leaq 0xb8908(%rip), %rdx # 0x176504
movb $0x0, %al
callq 0x3090
leaq 0x100(%rsp), %rdi
movq 0x230(%rsp), %rsi
callq 0x2f8f0
leaq 0xd4e59(%rip), %rax # 0x192a78
movq (%rax), %rax
movq 0x230(%rsp), %rcx
addq $0x3e8, %rcx # imm = 0x3E8
imulq $0x368, %rcx, %rcx # imm = 0x368
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0xbdc69
movq %rsp, %rdi
leaq 0xb7bae(%rip), %rsi # 0x1757f9
leaq 0xb88b2(%rip), %rdx # 0x176504
movb $0x0, %al
callq 0x3090
movq %rsp, %rdi
movq 0x230(%rsp), %rsi
callq 0x2f8f0
leaq 0xd4e08(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x200(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswq (%rax), %rax
movq %rax, 0x208(%rsp)
movq 0x228(%rsp), %rax
movq %rax, 0x210(%rsp)
movq $0x0, 0x218(%rsp)
movq 0x218(%rsp), %rax
cmpq 0x208(%rsp), %rax
jge 0xbdd61
movq 0x210(%rsp), %rax
leaq 0xd4da9(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x200(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movq 0x218(%rsp), %rdx
movslq 0xa0(%rcx,%rdx,4), %rcx
cqto
idivq %rcx
movq 0x220(%rsp), %rax
movq 0x218(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
leaq 0xd4d67(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x200(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x218(%rsp), %rcx
movslq 0xa0(%rax,%rcx,4), %rcx
movq 0x210(%rsp), %rax
cqto
idivq %rcx
movq %rax, 0x210(%rsp)
movq 0x218(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x218(%rsp)
jmp 0xbdcaa
addq $0x238, %rsp # imm = 0x238
retq
nopl (%rax)
| /GlobalArrays[P]ga/global/src/base.c |
pnga_access_ghost_ptr | void pnga_access_ghost_ptr(Integer g_a, Integer dims[],
void* ptr, Integer ld[])
{
char *lptr;
Integer handle = GA_OFFSET + g_a;
Integer i, lo[MAXDIM], hi[MAXDIM];
Integer ndim = GA[handle].ndim;
Integer me = pnga_nodeid();
pnga_distribution(g_a, me, lo, hi);
for (i=0; i < ndim; i++) {
dims[i] = 0;
}
gam_LocationWithGhosts(me, handle, dims, &lptr, ld);
*(char**)ptr = lptr;
for (i=0; i < ndim; i++)
dims[i] = hi[i] - lo[i] + 1 + 2*(Integer)GA[handle].width[i];
} | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rax
addq $0x3e8, %rax # imm = 0x3E8
movq %rax, 0x228(%rsp)
leaq 0x95f74(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswq (%rax), %rax
movq %rax, 0x198(%rsp)
movb $0x0, %al
callq 0xd4900
movq %rax, 0x190(%rsp)
movq 0x250(%rsp), %rdi
movq 0x190(%rsp), %rsi
leaq 0x1e0(%rsp), %rdx
leaq 0x1a0(%rsp), %rcx
callq 0xbdd70
movq $0x0, 0x220(%rsp)
movq 0x220(%rsp), %rax
cmpq 0x198(%rsp), %rax
jge 0xfcba2
movq 0x248(%rsp), %rax
movq 0x220(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x220(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x220(%rsp)
jmp 0xfcb62
movq $0x1, 0x180(%rsp)
leaq 0x95ec3(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswl (%rax), %eax
subl $0x1, %eax
cltq
movq %rax, 0x178(%rsp)
movq $0x0, 0x170(%rsp)
leaq 0x95e8e(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
cmpl $0x0, 0x224(%rax)
jne 0xfd347
leaq 0x95e68(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
cmpq $0x0, 0x2a8(%rax)
jne 0xfcf71
leaq 0x95e41(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswq (%rax), %rax
movq %rax, 0xc8(%rsp)
movq $0x0, 0xc0(%rsp)
movq $0x1, 0xe0(%rsp)
movq $0x0, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
cmpq 0xc8(%rsp), %rax
jge 0xfccdb
leaq 0x95de6(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0xd8(%rsp), %rcx
movslq 0xa0(%rax,%rcx,4), %rax
imulq 0xe0(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd8(%rsp)
jmp 0xfcc79
movq 0x190(%rsp), %rax
movq 0xe0(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0xfccff
cmpq $0x0, 0x190(%rsp)
jge 0xfcd60
movq $0x0, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
cmpq 0xc8(%rsp), %rax
jge 0xfcd5b
movq 0xd8(%rsp), %rax
movq $0x0, 0x130(%rsp,%rax,8)
movq 0xd8(%rsp), %rax
movq $-0x1, 0xf0(%rsp,%rax,8)
movq 0xd8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd8(%rsp)
jmp 0xfcd0b
jmp 0xfcf6c
movq 0x190(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq $0x0, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
cmpq 0xc8(%rsp), %rax
jge 0xfcf6a
movq 0xd0(%rsp), %rax
leaq 0x95cd7(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movslq 0xa0(%rcx,%rdx,4), %rcx
cqto
idivq %rcx
movq %rdx, 0xe8(%rsp)
leaq 0x95ca1(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0xd8(%rsp), %rcx
movslq 0xa0(%rax,%rcx,4), %rcx
movq 0xd0(%rsp), %rax
cqto
idivq %rcx
movq %rax, 0xd0(%rsp)
movq 0xe8(%rsp), %rax
addq 0xc0(%rsp), %rax
movq %rax, 0xb8(%rsp)
leaq 0x95c4b(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0xd8(%rsp), %rcx
movslq 0xa0(%rax,%rcx,4), %rax
addq 0xc0(%rsp), %rax
movq %rax, 0xc0(%rsp)
leaq 0x95c12(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x1e8(%rax), %rax
movq 0xb8(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0xd8(%rsp), %rax
movq %rcx, 0x130(%rsp,%rax,8)
movq 0xe8(%rsp), %rax
leaq 0x95bce(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movq 0xd8(%rsp), %rdx
movl 0xa0(%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0xfcf0e
leaq 0x95b9b(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0xd8(%rsp), %rcx
movq 0x30(%rax,%rcx,8), %rcx
movq 0xd8(%rsp), %rax
movq %rcx, 0xf0(%rsp,%rax,8)
jmp 0xfcf4f
leaq 0x95b63(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x1e8(%rax), %rax
movq 0xb8(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rcx
subq $0x1, %rcx
movq 0xd8(%rsp), %rax
movq %rcx, 0xf0(%rsp,%rax,8)
jmp 0xfcf51
movq 0xd8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd8(%rsp)
jmp 0xfcd7c
jmp 0xfcf6c
jmp 0xfd342
movq 0x190(%rsp), %rax
leaq 0x95af8(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
cmpq 0x2a8(%rcx), %rax
jge 0xfd2dd
leaq 0x95ad2(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswq (%rax), %rax
movq %rax, 0x90(%rsp)
movq $0x0, 0x88(%rsp)
movq $0x1, 0xa8(%rsp)
movq $0x0, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
cmpq 0x90(%rsp), %rax
jge 0xfd04a
leaq 0x95a77(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0xa0(%rsp), %rcx
movslq 0xa0(%rax,%rcx,4), %rax
imulq 0xa8(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa0(%rsp)
jmp 0xfcfe8
movq 0x190(%rsp), %rax
movq 0xa8(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jg 0xfd06e
cmpq $0x0, 0x190(%rsp)
jge 0xfd0cf
movq $0x0, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
cmpq 0x90(%rsp), %rax
jge 0xfd0ca
movq 0xa0(%rsp), %rax
movq $0x0, 0x130(%rsp,%rax,8)
movq 0xa0(%rsp), %rax
movq $-0x1, 0xf0(%rsp,%rax,8)
movq 0xa0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa0(%rsp)
jmp 0xfd07a
jmp 0xfd2db
movq 0x190(%rsp), %rax
movq %rax, 0x98(%rsp)
movq $0x0, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
cmpq 0x90(%rsp), %rax
jge 0xfd2d9
movq 0x98(%rsp), %rax
leaq 0x95968(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movq 0xa0(%rsp), %rdx
movslq 0xa0(%rcx,%rdx,4), %rcx
cqto
idivq %rcx
movq %rdx, 0xb0(%rsp)
leaq 0x95932(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0xa0(%rsp), %rcx
movslq 0xa0(%rax,%rcx,4), %rcx
movq 0x98(%rsp), %rax
cqto
idivq %rcx
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rax
addq 0x88(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x958dc(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0xa0(%rsp), %rcx
movslq 0xa0(%rax,%rcx,4), %rax
addq 0x88(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x958a3(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x1e8(%rax), %rax
movq 0x80(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0x130(%rsp,%rax,8)
movq 0xb0(%rsp), %rax
leaq 0x9585f(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movq 0xa0(%rsp), %rdx
movl 0xa0(%rcx,%rdx,4), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0xfd27d
leaq 0x9582c(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0xa0(%rsp), %rcx
movq 0x30(%rax,%rcx,8), %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0xf0(%rsp,%rax,8)
jmp 0xfd2be
leaq 0x957f4(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x1e8(%rax), %rax
movq 0x80(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rcx
subq $0x1, %rcx
movq 0xa0(%rsp), %rax
movq %rcx, 0xf0(%rsp,%rax,8)
jmp 0xfd2c0
movq 0xa0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa0(%rsp)
jmp 0xfd0eb
jmp 0xfd2db
jmp 0xfd340
leaq 0x95794(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswl (%rax), %eax
movl %eax, 0x78(%rsp)
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x78(%rsp), %eax
jge 0xfd33e
movslq 0x7c(%rsp), %rax
movq $0x0, 0x130(%rsp,%rax,8)
movslq 0x7c(%rsp), %rax
movq $-0x1, 0xf0(%rsp,%rax,8)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0xfd305
jmp 0xfd340
jmp 0xfd342
jmp 0xfd87d
leaq 0x9572a(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
cmpl $0x1, 0x224(%rax)
je 0xfd3b1
leaq 0x95708(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
cmpl $0x2, 0x224(%rax)
je 0xfd3b1
leaq 0x956e6(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
cmpl $0x3, 0x224(%rax)
jne 0xfd5e1
leaq 0x956c0(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswl (%rax), %eax
movl %eax, 0x48(%rsp)
leaq 0x956a0(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswl (%rax), %eax
movl %eax, 0x3c(%rsp)
movq 0x190(%rsp), %rax
movl %eax, 0x44(%rsp)
movslq 0x44(%rsp), %rax
leaq 0x9566f(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
cqto
idivq 0x260(%rcx)
movl %edx, %eax
movl %eax, 0x50(%rsp)
movl $0x1, 0x40(%rsp)
movl 0x40(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0xfd4cd
movl 0x44(%rsp), %eax
movl 0x40(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
subl 0x50(%rsp,%rcx,4), %eax
cltq
leaq 0x9561d(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movl 0x40(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rsi
cqto
idivq 0x260(%rcx,%rsi,8)
movl %eax, 0x44(%rsp)
movslq 0x44(%rsp), %rax
leaq 0x955e7(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movslq 0x40(%rsp), %rsi
cqto
idivq 0x260(%rcx,%rsi,8)
movl %edx, %ecx
movslq 0x40(%rsp), %rax
movl %ecx, 0x50(%rsp,%rax,4)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0xfd432
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x48(%rsp), %eax
jge 0xfd5dc
movslq 0x4c(%rsp), %rax
movslq 0x50(%rsp,%rax,4), %rcx
leaq 0x95584(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rax
movslq 0x4c(%rsp), %rdx
imulq 0x228(%rax,%rdx,8), %rcx
addq $0x1, %rcx
movslq 0x4c(%rsp), %rax
movq %rcx, 0x130(%rsp,%rax,8)
movslq 0x4c(%rsp), %rax
movl 0x50(%rsp,%rax,4), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x9553d(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rax
movslq 0x4c(%rsp), %rdx
imulq 0x228(%rax,%rdx,8), %rcx
movslq 0x4c(%rsp), %rax
movq %rcx, 0xf0(%rsp,%rax,8)
movslq 0x4c(%rsp), %rax
movq 0xf0(%rsp,%rax,8), %rax
leaq 0x954fc(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movslq 0x4c(%rsp), %rdx
cmpq 0x30(%rcx,%rdx,8), %rax
jle 0xfd5ca
leaq 0x954d7(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movslq 0x4c(%rsp), %rcx
movq 0x30(%rax,%rcx,8), %rcx
movslq 0x4c(%rsp), %rax
movq %rcx, 0xf0(%rsp,%rax,8)
jmp 0xfd5cc
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0xfd4d5
jmp 0xfd87b
leaq 0x95490(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
cmpl $0x4, 0x224(%rax)
jne 0xfd879
leaq 0x9546a(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswl (%rax), %eax
movl %eax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
leaq 0x95442(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movswl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x190(%rsp), %rax
movl %eax, 0x10(%rsp)
movslq 0x10(%rsp), %rax
leaq 0x95411(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
cqto
idivq 0x260(%rcx)
movl %edx, %eax
movl %eax, 0x20(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0xfd72b
movl 0x10(%rsp), %eax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
subl 0x20(%rsp,%rcx,4), %eax
cltq
leaq 0x953bf(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movl 0xc(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rsi
cqto
idivq 0x260(%rcx,%rsi,8)
movl %eax, 0x10(%rsp)
movslq 0x10(%rsp), %rax
leaq 0x95389(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movslq 0xc(%rsp), %rsi
cqto
idivq 0x260(%rcx,%rsi,8)
movl %edx, %ecx
movslq 0xc(%rsp), %rax
movl %ecx, 0x20(%rsp,%rax,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xfd690
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jge 0xfd877
leaq 0x95330(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x1e8(%rax), %rax
movl 0x14(%rsp), %ecx
movslq 0x1c(%rsp), %rdx
addl 0x20(%rsp,%rdx,4), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movslq 0x1c(%rsp), %rax
movq %rcx, 0x130(%rsp,%rax,8)
movslq 0x1c(%rsp), %rax
movslq 0x20(%rsp,%rax,4), %rax
leaq 0x952e5(%rip), %rcx # 0x192a78
movq (%rcx), %rcx
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rcx
movslq 0x1c(%rsp), %rdx
movq 0x260(%rcx,%rdx,8), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0xfd805
leaq 0x952b6(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x1e8(%rax), %rax
movl 0x14(%rsp), %ecx
movslq 0x1c(%rsp), %rdx
addl 0x20(%rsp,%rdx,4), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
subq $0x1, %rcx
movslq 0x1c(%rsp), %rax
movq %rcx, 0xf0(%rsp,%rax,8)
jmp 0xfd835
leaq 0x9526c(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movslq 0x1c(%rsp), %rcx
movq 0x30(%rax,%rcx,8), %rcx
movslq 0x1c(%rsp), %rax
movq %rcx, 0xf0(%rsp,%rax,8)
leaq 0x9523c(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movslq 0x1c(%rsp), %rcx
movq 0x260(%rax,%rcx,8), %rcx
movslq 0x14(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xfd733
jmp 0xfd879
jmp 0xfd87b
jmp 0xfd87d
cmpq $0x0, 0x178(%rsp)
jne 0xfd8cd
movq 0xf0(%rsp), %rcx
subq 0x130(%rsp), %rcx
addq $0x1, %rcx
leaq 0x951d5(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rdx # imm = 0x368
addq %rdx, %rax
movq 0xc0(%rax), %rax
shlq %rax
addq %rax, %rcx
movq 0x238(%rsp), %rax
movq %rcx, (%rax)
movq $0x0, 0x188(%rsp)
movq 0x188(%rsp), %rax
cmpq 0x178(%rsp), %rax
jge 0xfd9c1
movq 0x248(%rsp), %rax
movq 0x188(%rsp), %rcx
movq (%rax,%rcx,8), %rax
imulq 0x180(%rsp), %rax
addq 0x170(%rsp), %rax
movq %rax, 0x170(%rsp)
movq 0x188(%rsp), %rax
movq 0xf0(%rsp,%rax,8), %rdx
movq 0x188(%rsp), %rax
subq 0x130(%rsp,%rax,8), %rdx
addq $0x1, %rdx
leaq 0x95131(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x188(%rsp), %rcx
movq 0xc0(%rax,%rcx,8), %rax
shlq %rax
addq %rax, %rdx
movq 0x238(%rsp), %rax
movq 0x188(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x238(%rsp), %rax
movq 0x188(%rsp), %rcx
movq (%rax,%rcx,8), %rax
imulq 0x180(%rsp), %rax
movq %rax, 0x180(%rsp)
movq 0x188(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x188(%rsp)
jmp 0xfd8d9
movq 0x248(%rsp), %rax
movq 0x178(%rsp), %rcx
movq (%rax,%rcx,8), %rax
imulq 0x180(%rsp), %rax
addq 0x170(%rsp), %rax
movq %rax, 0x170(%rsp)
leaq 0x95083(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x1e0(%rax), %rax
movq 0x190(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x170(%rsp), %rcx
leaq 0x9504f(%rip), %rdx # 0x192a78
movq (%rdx), %rdx
imulq $0x368, 0x228(%rsp), %rsi # imm = 0x368
addq %rsi, %rdx
movslq 0x18(%rdx), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x230(%rsp)
movq 0x230(%rsp), %rcx
movq 0x240(%rsp), %rax
movq %rcx, (%rax)
movq $0x0, 0x220(%rsp)
movq 0x220(%rsp), %rax
cmpq 0x198(%rsp), %rax
jge 0xfdb03
movq 0x220(%rsp), %rax
movq 0x1a0(%rsp,%rax,8), %rdx
movq 0x220(%rsp), %rax
subq 0x1e0(%rsp,%rax,8), %rdx
addq $0x1, %rdx
leaq 0x94fca(%rip), %rax # 0x192a78
movq (%rax), %rax
imulq $0x368, 0x228(%rsp), %rcx # imm = 0x368
addq %rcx, %rax
movq 0x220(%rsp), %rcx
movq 0xc0(%rax,%rcx,8), %rax
shlq %rax
addq %rax, %rdx
movq 0x248(%rsp), %rax
movq 0x220(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x220(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x220(%rsp)
jmp 0xfda6d
addq $0x258, %rsp # imm = 0x258
retq
nopl (%rax,%rax)
| /GlobalArrays[P]ga/global/src/ghosts.c |
NGA_Set_data64 | void NGA_Set_data64(int g_a, int ndim, int64_t dims[], int type)
{
Integer aa, nndim, ttype;
Integer _ga_dims[MAXDIM];
COPYC2F(dims,_ga_dims, ndim);
aa = (Integer)g_a;
nndim = (Integer)ndim;
ttype = (Integer)type;
wnga_set_data(aa, nndim, _ga_dims, ttype);
} | subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movl %esi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x70(%rsp), %eax
jge 0x139d04
movq 0x68(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movl 0x70(%rsp), %eax
subl 0xc(%rsp), %eax
subl $0x1, %eax
cltq
movq %rcx, 0x10(%rsp,%rax,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x139ccd
movslq 0x74(%rsp), %rax
movq %rax, 0x58(%rsp)
movslq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movslq 0x64(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0xbfcc0
addq $0x78, %rsp
retq
| /GlobalArrays[P]ga/global/src/capi.c |
NGA_Set_block_cyclic | void NGA_Set_block_cyclic(int g_a, int dims[])
{
Integer aa, ndim;
Integer _ga_dims[MAXDIM];
aa = (Integer)g_a;
ndim = wnga_get_dimension(aa);
COPYC2F(dims,_ga_dims, ndim);
wnga_set_block_cyclic(aa, _ga_dims);
} | subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
movslq 0x64(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc08a0
movq %rax, 0x48(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
cmpq 0x48(%rsp), %rax
jge 0x13a1eb
movq 0x58(%rsp), %rax
movslq 0xc(%rsp), %rcx
movslq (%rax,%rcx,4), %rcx
movq 0x48(%rsp), %rax
movslq 0xc(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0x10(%rsp,%rax,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x13a1ae
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc08d0
addq $0x68, %rsp
retq
nop
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Scan_add | void GA_Scan_add(int g_a, int g_b, int g_sbit, int lo,
int hi, int excl)
{
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer s = (Integer)g_sbit;
Integer x = (Integer)excl;
Integer alo = lo+1;
Integer ahi = hi+1;
wnga_scan_add(a, b, s, alo, ahi, x);
} | subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movl %r9d, 0x30(%rsp)
movslq 0x44(%rsp), %rax
movq %rax, 0x28(%rsp)
movslq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movslq 0x3c(%rsp), %rax
movq %rax, 0x18(%rsp)
movslq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
cltq
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
cltq
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x5a070
addq $0x48, %rsp
retq
nopl (%rax,%rax)
| /GlobalArrays[P]ga/global/src/capi.c |
GA_Median_patch64 | void GA_Median_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,
int g_m, int64_t *mlo, int64_t *mhi){
Integer a = (Integer)g_a;
Integer b = (Integer)g_b;
Integer c = (Integer)g_c;
Integer m = (Integer )g_m;
Integer andim = wnga_ndim(a);
Integer bndim = wnga_ndim(b);
Integer cndim = wnga_ndim(c);
Integer mndim = wnga_ndim(m);
Integer _ga_alo[MAXDIM], _ga_ahi[MAXDIM];
Integer _ga_blo[MAXDIM], _ga_bhi[MAXDIM];
Integer _ga_clo[MAXDIM], _ga_chi[MAXDIM];
Integer _ga_mlo[MAXDIM], _ga_mhi[MAXDIM];
COPYINDEX_C2F(alo,_ga_alo, andim);
COPYINDEX_C2F(ahi,_ga_ahi, andim);
COPYINDEX_C2F(blo,_ga_blo, bndim);
COPYINDEX_C2F(bhi,_ga_bhi, bndim);
COPYINDEX_C2F(clo,_ga_clo, cndim);
COPYINDEX_C2F(chi,_ga_chi, cndim);
COPYINDEX_C2F(mlo,_ga_mlo, mndim);
COPYINDEX_C2F(mhi,_ga_mhi, mndim);
wnga_median_patch(a, _ga_alo, _ga_ahi, b, _ga_blo, _ga_bhi, c, _ga_clo, _ga_chi, m, _ga_mlo, _ga_mhi);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x2c0, %rsp # imm = 0x2C0
movq 0x308(%rsp), %rax
movq 0x300(%rsp), %rax
movl 0x2f8(%rsp), %eax
movq 0x2f0(%rsp), %rax
movq 0x2e8(%rsp), %rax
movl 0x2e0(%rsp), %eax
movl %edi, 0x2bc(%rsp)
movq %rsi, 0x2b0(%rsp)
movq %rdx, 0x2a8(%rsp)
movl %ecx, 0x2a4(%rsp)
movq %r8, 0x298(%rsp)
movq %r9, 0x290(%rsp)
movslq 0x2bc(%rsp), %rax
movq %rax, 0x288(%rsp)
movslq 0x2a4(%rsp), %rax
movq %rax, 0x280(%rsp)
movslq 0x2e0(%rsp), %rax
movq %rax, 0x278(%rsp)
movslq 0x2f8(%rsp), %rax
movq %rax, 0x270(%rsp)
movq 0x288(%rsp), %rdi
callq 0xcbc80
movq %rax, 0x268(%rsp)
movq 0x280(%rsp), %rdi
callq 0xcbc80
movq %rax, 0x260(%rsp)
movq 0x278(%rsp), %rdi
callq 0xcbc80
movq %rax, 0x258(%rsp)
movq 0x270(%rsp), %rdi
callq 0xcbc80
movq %rax, 0x250(%rsp)
movl $0x0, 0x4c(%rsp)
movslq 0x4c(%rsp), %rax
cmpq 0x268(%rsp), %rax
jge 0x14e291
movq 0x2b0(%rsp), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq 0x268(%rsp), %rax
movslq 0x4c(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0x210(%rsp,%rax,8)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x14e244
movl $0x0, 0x48(%rsp)
movslq 0x48(%rsp), %rax
cmpq 0x268(%rsp), %rax
jge 0x14e2e6
movq 0x2a8(%rsp), %rax
movslq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq 0x268(%rsp), %rax
movslq 0x48(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0x1d0(%rsp,%rax,8)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x14e299
movl $0x0, 0x44(%rsp)
movslq 0x44(%rsp), %rax
cmpq 0x260(%rsp), %rax
jge 0x14e33b
movq 0x298(%rsp), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq 0x260(%rsp), %rax
movslq 0x44(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0x190(%rsp,%rax,8)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x14e2ee
movl $0x0, 0x40(%rsp)
movslq 0x40(%rsp), %rax
cmpq 0x260(%rsp), %rax
jge 0x14e390
movq 0x290(%rsp), %rax
movslq 0x40(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq 0x260(%rsp), %rax
movslq 0x40(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0x150(%rsp,%rax,8)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x14e343
movl $0x0, 0x3c(%rsp)
movslq 0x3c(%rsp), %rax
cmpq 0x258(%rsp), %rax
jge 0x14e3e5
movq 0x2e8(%rsp), %rax
movslq 0x3c(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq 0x258(%rsp), %rax
movslq 0x3c(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0x110(%rsp,%rax,8)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x14e398
movl $0x0, 0x38(%rsp)
movslq 0x38(%rsp), %rax
cmpq 0x258(%rsp), %rax
jge 0x14e43a
movq 0x2f0(%rsp), %rax
movslq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq 0x258(%rsp), %rax
movslq 0x38(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0xd0(%rsp,%rax,8)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x14e3ed
movl $0x0, 0x34(%rsp)
movslq 0x34(%rsp), %rax
cmpq 0x250(%rsp), %rax
jge 0x14e48f
movq 0x300(%rsp), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq 0x250(%rsp), %rax
movslq 0x34(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0x90(%rsp,%rax,8)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x14e442
movl $0x0, 0x30(%rsp)
movslq 0x30(%rsp), %rax
cmpq 0x250(%rsp), %rax
jge 0x14e4e1
movq 0x308(%rsp), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq 0x250(%rsp), %rax
movslq 0x30(%rsp), %rdx
subq %rdx, %rax
subq $0x1, %rax
movq %rcx, 0x50(%rsp,%rax,8)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x14e497
movq 0x288(%rsp), %rdi
leaq 0x210(%rsp), %rsi
leaq 0x1d0(%rsp), %rdx
movq 0x280(%rsp), %rcx
leaq 0x190(%rsp), %r8
leaq 0x150(%rsp), %r9
movq 0x278(%rsp), %r15
leaq 0x110(%rsp), %r14
leaq 0xd0(%rsp), %rbx
movq 0x270(%rsp), %r11
leaq 0x90(%rsp), %r10
leaq 0x50(%rsp), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x4a860
addq $0x2c0, %rsp # imm = 0x2C0
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
| /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] ;
pedims[idim] = bq;
npes /= bq;
npes = (npes<1) ? 1 : npes;
if(idim<ndims-2){
qedims[idim+1] = (double) npes;
for(i=idim+2;i<ndims;i++) qedims[idim+1] /=
(ardims[i]/(double)ardims[idim+1]);
qedims[idim+1] = (double) pow(qedims[idim+1],
1.0/(double)(ndims-1-idim));
for(i=idim+2;i<ndims;i++){
qedims[i] = (ardims[i]/(double)ardims[idim+1])*
qedims[idim+1];
}
if(bq>1) {
for(k=1,i=g+1;i<npdivs;i++){
if(pdivs[i]%bq==0) {
pdivs[k] = pdivs[i]/bq;
k += 1;
}
}
npdivs = k;
}
}
}
pedims[ndims-1] = npes;
} | subq $0x68, %rsp
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x1520a6
movq 0x70(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x1520d0
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
cqto
idivq %rcx
movq %rax, 0x40(%rsp)
cmpq $0x1, 0x40(%rsp)
jge 0x151e98
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x151ea2
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jge 0x152091
cvtsi2sdq 0x40(%rsp), %xmm0
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x60(%rsp), %rax
jge 0x151f43
movq 0x50(%rsp), %rax
movq 0x28(%rsp), %rcx
cvtsi2sdq (%rax,%rcx,8), %xmm1
movq 0x50(%rsp), %rax
movq 0x10(%rsp), %rcx
cvtsi2sdq 0x8(%rax,%rcx,8), %xmm0
divsd %xmm0, %xmm1
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax,%rcx,8)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x151ee8
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
movq 0x60(%rsp), %rax
subq $0x1, %rax
subq 0x10(%rsp), %rax
cvtsi2sd %rax, %xmm2
movsd 0x1b852(%rip), %xmm1 # 0x16d7c0
divsd %xmm2, %xmm1
callq 0x3470
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x60(%rsp), %rax
jge 0x151ff5
movq 0x50(%rsp), %rax
movq 0x28(%rsp), %rcx
cvtsi2sdq (%rax,%rcx,8), %xmm0
movq 0x50(%rsp), %rax
movq 0x10(%rsp), %rcx
cvtsi2sdq 0x8(%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
movq 0x58(%rsp), %rax
movq 0x10(%rsp), %rcx
mulsd 0x8(%rax,%rcx,8), %xmm0
movq 0x58(%rsp), %rax
movq 0x28(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x151f95
cmpq $0x1, 0x30(%rsp)
jle 0x15208f
movq $0x1, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jge 0x152085
movq 0x70(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cqto
idivq 0x30(%rsp)
cmpq $0x0, %rdx
jne 0x152073
movq 0x70(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cqto
idivq 0x30(%rsp)
movq %rax, %rdx
movq 0x70(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x152075
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x152018
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x152091
jmp 0x152093
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x151e10
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rax
movq 0x60(%rsp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| /GlobalArrays[P]ga/global/src/decomp.c |
cs_strerror | CAPSTONE_EXPORT
const char *cs_strerror(cs_err code)
{
switch(code) {
default:
return "Unknown error code";
case CS_ERR_OK:
return "OK (CS_ERR_OK)";
case CS_ERR_MEM:
return "Out of memory (CS_ERR_MEM)";
case CS_ERR_ARCH:
return "Invalid architecture (CS_ERR_ARCH)";
case CS_ERR_HANDLE:
return "Invalid handle (CS_ERR_HANDLE)";
case CS_ERR_CSH:
return "Invalid csh (CS_ERR_CSH)";
case CS_ERR_MODE:
return "Invalid mode (CS_ERR_MODE)";
case CS_ERR_OPTION:
return "Invalid option (CS_ERR_OPTION)";
case CS_ERR_DETAIL:
return "Details are unavailable (CS_ERR_DETAIL)";
case CS_ERR_MEMSETUP:
return "Dynamic memory management uninitialized (CS_ERR_MEMSETUP)";
case CS_ERR_VERSION:
return "Different API version between core & binding (CS_ERR_VERSION)";
case CS_ERR_DIET:
return "Information irrelevant in diet engine (CS_ERR_DIET)";
case CS_ERR_SKIPDATA:
return "Information irrelevant for 'data' instruction in SKIPDATA mode (CS_ERR_SKIPDATA)";
}
} | cmpl $0xb, %edi
ja 0x43512
movl %edi, %eax
leaq 0x7eec6(%rip), %rcx # 0xc23d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x7eee7(%rip), %rax # 0xc2400
retq
| /bughoho[P]capstone/cs.c |
cs_option | CAPSTONE_EXPORT
cs_err cs_option(csh ud, cs_opt_type type, size_t value)
{
struct cs_struct *handle;
archs_enable();
// cs_option() can be called with NULL handle just for CS_OPT_MEM
// This is supposed to be executed before all other APIs (even cs_open())
if (type == CS_OPT_MEM) {
cs_opt_mem *mem = (cs_opt_mem *)value;
cs_mem_malloc = mem->malloc;
cs_mem_calloc = mem->calloc;
cs_mem_realloc = mem->realloc;
cs_mem_free = mem->free;
cs_vsnprintf = mem->vsnprintf;
return CS_ERR_OK;
}
handle = (struct cs_struct *)(uintptr_t)ud;
if (!handle)
return CS_ERR_CSH;
switch(type) {
default:
break;
case CS_OPT_DETAIL:
handle->detail = (cs_opt_value)value;
return CS_ERR_OK;
case CS_OPT_SKIPDATA:
handle->skipdata = (value == CS_OPT_ON);
if (handle->skipdata) {
if (handle->skipdata_size == 0) {
// set the default skipdata size
handle->skipdata_size = skipdata_size(handle);
}
}
return CS_ERR_OK;
case CS_OPT_SKIPDATA_SETUP:
if (value)
handle->skipdata_setup = *((cs_opt_skipdata *)value);
return CS_ERR_OK;
}
return arch_option[handle->arch](handle, type, value);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x43479
cmpl $0x4, %ebp
jne 0x436d9
movq (%rbx), %rax
movq %rax, 0x150a07(%rip) # 0x1940b0
movq 0x8(%rbx), %rax
movq %rax, 0x150a04(%rip) # 0x1940b8
movq 0x10(%rbx), %rax
movq %rax, 0x150a01(%rip) # 0x1940c0
movq 0x18(%rbx), %rax
movq %rax, 0x1509fe(%rip) # 0x1940c8
movq 0x20(%rbx), %rax
movq %rax, 0x1509fb(%rip) # 0x1940d0
xorl %ebp, %ebp
jmp 0x43742
testq %r14, %r14
je 0x436f3
cmpl $0x6, %ebp
je 0x43725
cmpl $0x5, %ebp
je 0x436fa
cmpl $0x2, %ebp
jne 0x43749
movl %ebx, 0x68(%r14)
jmp 0x436d5
movl $0x4, %ebp
jmp 0x43742
xorl %ebp, %ebp
cmpq $0x3, %rbx
sete 0x88(%r14)
jne 0x43742
cmpb $0x0, 0x89(%r14)
jne 0x43742
movq %r14, %rdi
callq 0x43765
movb %al, 0x89(%r14)
jmp 0x43742
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x43742
movq 0x10(%rbx), %rax
movq %rax, 0xa0(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x90(%r14)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl (%r14), %eax
leaq 0x24444d(%rip), %rcx # 0x287ba0
movq (%rcx,%rax,8), %rax
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
| /bughoho[P]capstone/cs.c |
cs_free | CAPSTONE_EXPORT
void cs_free(cs_insn *insn, size_t count)
{
size_t i;
// free all detail pointers
for (i = 0; i < count; i++)
cs_mem_free(insn[i].detail);
// then free pointer to cs_insn array
cs_mem_free(insn);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x43d8c
movq %rsi, %r14
leaq 0xe8(%rbx), %r15
movq (%r15), %rdi
callq *0x150348(%rip) # 0x1940c8
addq $0xf0, %r15
decq %r14
jne 0x43d77
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0x15032e(%rip) # 0x1940c8
| /bughoho[P]capstone/cs.c |
cs_reg_write | CAPSTONE_EXPORT
bool cs_reg_write(csh ud, const cs_insn *insn, unsigned int reg_id)
{
struct cs_struct *handle;
if (!ud)
return false;
handle = (struct cs_struct *)(uintptr_t)ud;
if (!handle->detail) {
handle->errnum = CS_ERR_DETAIL;
return false;
}
if(!insn->id) {
handle->errnum = CS_ERR_SKIPDATA;
return false;
}
if(!insn->detail) {
handle->errnum = CS_ERR_DETAIL;
return false;
}
return arr_exist(insn->detail->regs_write, insn->detail->regs_write_count, reg_id);
} | testq %rdi, %rdi
je 0x44111
cmpl $0x0, 0x68(%rdi)
je 0x44101
cmpl $0x0, (%rsi)
je 0x4410a
movq 0xe8(%rsi), %rcx
testq %rcx, %rcx
je 0x44101
movzbl 0x21(%rcx), %esi
testq %rsi, %rsi
je 0x44111
movzbl 0xd(%rcx), %edi
movb $0x1, %al
cmpl %edx, %edi
je 0x44100
leaq -0x1(%rsi), %rax
xorl %r8d, %r8d
movq %r8, %rdi
cmpq %r8, %rax
je 0x440f7
movzbl 0xe(%rcx,%rdi), %r9d
leaq 0x1(%rdi), %r8
cmpl %edx, %r9d
jne 0x440e0
incq %rdi
cmpq %rsi, %rdi
setb %al
retq
movl $0x7, 0x58(%rdi)
jmp 0x44111
movl $0xb, 0x58(%rdi)
xorl %eax, %eax
retq
| /bughoho[P]capstone/cs.c |
printInt64Bang | void printInt64Bang(SStream *O, int64_t val)
{
if (val >= 0) {
if (val > HEX_THRESHOLD)
SStream_concat(O, "#0x%"PRIx64, val);
else
SStream_concat(O, "#%"PRIu64, val);
} else {
if (val <- HEX_THRESHOLD)
SStream_concat(O, "#-0x%"PRIx64, -val);
else
SStream_concat(O, "#-%"PRIu64, -val);
}
} | movq %rsi, %rax
testq %rsi, %rsi
js 0x44787
cmpq $0xa, %rax
jb 0x4479c
leaq 0x7de81(%rip), %rsi # 0xc2606
jmp 0x447a3
movq %rax, %rdx
negq %rdx
cmpq $-0xa, %rax
ja 0x447a8
leaq 0x7de78(%rip), %rsi # 0xc2612
jmp 0x447af
leaq 0x7de6a(%rip), %rsi # 0xc260d
movq %rax, %rdx
jmp 0x447af
leaq 0x7de6b(%rip), %rsi # 0xc261a
xorl %eax, %eax
jmp 0x446c5
| /bughoho[P]capstone/SStream.c |
printInt32Bang | void printInt32Bang(SStream *O, int32_t val)
{
if (val >= 0) {
if (val > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", val);
else
SStream_concat(O, "#%u", val);
} else {
if (val <- HEX_THRESHOLD)
SStream_concat(O, "#-0x%x", -val);
else
SStream_concat(O, "#-%u", -val);
}
} | movl %esi, %eax
testl %esi, %esi
js 0x44854
cmpl $0xa, %eax
jb 0x44866
leaq 0x908e4(%rip), %rsi # 0xd5136
jmp 0x4486d
movl %eax, %edx
negl %edx
cmpl $-0xa, %eax
ja 0x44871
leaq 0x908c2(%rip), %rsi # 0xd5126
jmp 0x44878
leaq 0x908d1(%rip), %rsi # 0xd513e
movl %eax, %edx
jmp 0x44878
leaq 0x908b7(%rip), %rsi # 0xd512f
xorl %eax, %eax
jmp 0x446c5
| /bughoho[P]capstone/SStream.c |
LowerBound(ImVector<ImGuiStorage::ImGuiStoragePair>&, unsigned int) | static ImGuiStorage::ImGuiStoragePair* LowerBound(ImVector<ImGuiStorage::ImGuiStoragePair>& data, ImGuiID key)
{
ImGuiStorage::ImGuiStoragePair* first = data.Data;
ImGuiStorage::ImGuiStoragePair* last = data.Data + data.Size;
size_t count = (size_t)(last - first);
while (count > 0)
{
size_t count2 = count >> 1;
ImGuiStorage::ImGuiStoragePair* mid = first + count2;
if (mid->key < key)
{
first = ++mid;
count -= count2 + 1;
}
else
{
count = count2;
}
}
return first;
} | movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
testq %rcx, %rcx
je 0x26336
movq %rcx, %rdx
shrq %rdx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpl %esi, (%rax,%rdi)
jae 0x26331
notq %rdx
addq %rcx, %rdx
addq %rdi, %rax
addq $0x10, %rax
movq %rdx, %rcx
jmp 0x2630d
retq
nop
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGuiStorage::GetFloatRef(unsigned int, float) | float* ImGuiStorage::GetFloatRef(ImGuiID key, float 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_f;
} | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movss %xmm0, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
callq 0x26306
movslq (%rbx), %rcx
shlq $0x4, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x26438
cmpl %ebp, (%rax)
je 0x26455
leaq 0x8(%rsp), %rdx
movl %ebp, (%rdx)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x8(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4866a
addq $0x8, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| /binji[P]binjgb/third_party/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;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x26306
movslq (%rbx), %rcx
shlq $0x4, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x26489
cmpl %ebp, (%rax)
je 0x2649d
movq %rsp, %rdx
movl %ebp, (%rdx)
movq %r14, 0x8(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4866a
addq $0x8, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::CalcListClipping(int, float, int*, int*) | void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (g.LogEnabled)
{
// If logging is active, do not perform any clipping
*out_items_display_start = 0;
*out_items_display_end = items_count;
return;
}
if (GetSkipItemForListClipping())
{
*out_items_display_start = *out_items_display_end = 0;
return;
}
// We create the union of the ClipRect and the scoring rect which at worst should be 1 page away from ClipRect
ImRect unclipped_rect = window->ClipRect;
if (g.NavMoveScoringItems)
unclipped_rect.Add(g.NavScoringRect);
if (g.NavJustMovedToId && window->NavLastIds[0] == g.NavJustMovedToId)
unclipped_rect.Add(ImRect(window->Pos + window->NavRectRel[0].Min, window->Pos + window->NavRectRel[0].Max)); // Could store and use NavJustMovedToRectRel
const ImVec2 pos = window->DC.CursorPos;
int start = (int)((unclipped_rect.Min.y - pos.y) / items_height);
int end = (int)((unclipped_rect.Max.y - pos.y) / items_height);
// When performing a navigation request, ensure we have one item extra in the direction we are moving to
if (g.NavMoveScoringItems && g.NavMoveClipDir == ImGuiDir_Up)
start--;
if (g.NavMoveScoringItems && g.NavMoveClipDir == ImGuiDir_Down)
end++;
start = ImClamp(start, 0, items_count);
end = ImClamp(end + 1, start, items_count);
*out_items_display_start = start;
*out_items_display_end = end;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0xb6ac6(%rip), %r15 # 0xdd4d8
cmpb $0x1, 0x32b4(%r15)
jne 0x26a25
andl $0x0, (%r14)
jmp 0x26b66
movq 0x1d18(%r15), %r12
movq 0x21a0(%r15), %rax
leaq 0x207(%rax), %rcx
leaq 0xcc(%r12), %rdx
testq %rax, %rax
cmoveq %rdx, %rcx
cmpb $0x1, (%rcx)
jne 0x26a5a
andl $0x0, (%rbx)
andl $0x0, (%r14)
jmp 0x26b68
movups 0x240(%r12), %xmm1
movaps %xmm1, (%rsp)
cmpb $0x1, 0x1fed(%r15)
jne 0x26a8a
leaq 0x2008(%r15), %rsi
movq %rsp, %rdi
movaps %xmm0, 0x10(%rsp)
callq 0x4892e
movaps 0x10(%rsp), %xmm0
movl 0x1fb0(%r15), %eax
testl %eax, %eax
je 0x26adc
cmpl %eax, 0x3b0(%r12)
jne 0x26adc
movss 0x4c(%r12), %xmm3
movss 0x3bc(%r12), %xmm1
addss %xmm3, %xmm1
addss 0x3c4(%r12), %xmm3
movss 0x4(%rsp), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x26acf
movss %xmm1, 0x4(%rsp)
ucomiss 0xc(%rsp), %xmm3
jbe 0x26adc
movss %xmm3, 0xc(%rsp)
movaps (%rsp), %xmm2
movss 0x4(%rsp), %xmm1
shufps $0xf4, %xmm2, %xmm1 # xmm1 = xmm1[0,1],xmm2[3,3]
shufps $0xf2, %xmm2, %xmm1 # xmm1 = xmm1[2,0],xmm2[3,3]
movss 0x114(%r12), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
subps %xmm2, %xmm1
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
divps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
cmpb $0x1, 0x1fed(%r15)
jne 0x26b3c
movd 0x2004(%r15), %xmm1
pshufd $0x50, %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1]
pcmpeqd 0x76616(%rip), %xmm1 # 0x9d140
pshufd $0x55, %xmm1, %xmm2 # xmm2 = xmm1[1,1,1,1]
psrld $0x1f, %xmm1
punpckldq %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
paddd %xmm1, %xmm0
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
movd %xmm1, %eax
cmpl %ebp, %eax
movl %ebp, %ecx
cmovll %eax, %ecx
xorl %edx, %edx
testl %eax, %eax
cmovnsl %ecx, %edx
movd %xmm0, %eax
incl %eax
cmpl %ebp, %eax
cmovll %eax, %ebp
cmpl %edx, %eax
cmovll %edx, %ebp
movl %edx, (%r14)
movl %ebp, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::PushStyleVar(int, ImVec2 const&) | void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
{
ImGuiContext& g = *GImGui;
ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&g.Style);
g.StyleVarStack.push_back(ImGuiStyleMod(idx, *pvar));
*pvar = val;
return;
}
IM_ASSERT(0 && "Called PushStyleVar() ImVec2 variant but variable is not a ImVec2!");
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0x271f7
cmpl $0x8, (%rax)
jne 0x2728f
cmpl $0x2, 0x4(%rax)
jne 0x2728f
movq 0xb6285(%rip), %r14 # 0xdd4d8
movl 0x8(%rax), %r15d
leaq 0x1eb8(%r14), %rdi
movsd 0x1640(%r14,%r15), %xmm0
leaq 0xc(%rsp), %rsi
movl %ebp, (%rsi)
movsd %xmm0, 0x4(%rsi)
callq 0x48a34
movq (%rbx), %rax
movq %rax, 0x1640(%r14,%r15)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x76ed1(%rip), %rdi # 0x9e167
leaq 0x76af4(%rip), %rsi # 0x9dd91
leaq 0x76f0d(%rip), %rcx # 0x9e1b1
movl $0xa54, %edx # imm = 0xA54
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::RenderText(ImVec2, char const*, char const*, bool) | void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
// Hide anything after a '##' string
const char* text_display_end;
if (hide_text_after_hash)
{
text_display_end = FindRenderedTextEnd(text, text_end);
}
else
{
if (!text_end)
text_end = text + strlen(text); // FIXME-OPT
text_display_end = text_end;
}
if (text != text_display_end)
{
window->DrawList->AddText(g.Font, g.FontSize, pos, GetColorU32(ImGuiCol_Text), text, text_display_end);
if (g.LogEnabled)
LogRenderedText(&pos, text, text_display_end);
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, 0x18(%rsp)
movq 0xb6119(%rip), %r13 # 0xdd4d8
movq 0x1d18(%r13), %r15
testl %edx, %edx
je 0x273da
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27372
movq %rax, %r14
jmp 0x273ed
testq %r14, %r14
jne 0x273ed
movq %rbx, %rdi
callq 0x24280
movq %rax, %r14
addq %rbx, %r14
cmpq %rbx, %r14
je 0x2745e
movq 0x2a8(%r15), %r15
movq 0x1a80(%r13), %r12
movss 0x1a88(%r13), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x75fbd(%rip), %xmm0 # 0x9d3d4
xorl %edi, %edi
callq 0x26fc5
andq $0x0, (%rsp)
leaq 0x18(%rsp), %rdx
xorps %xmm1, %xmm1
movq %r15, %rdi
movq %r12, %rsi
movss 0x14(%rsp), %xmm0
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x4fff0
cmpb $0x1, 0x32b4(%r13)
jne 0x2745e
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2746c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::RenderTextClippedEx(ImDrawList*, ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*) | void ImGui::RenderTextClippedEx(ImDrawList* draw_list, const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_display_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
// Perform CPU side clipping for single clipped element to avoid using scissor state
ImVec2 pos = pos_min;
const ImVec2 text_size = text_size_if_known ? *text_size_if_known : CalcTextSize(text, text_display_end, false, 0.0f);
const ImVec2* clip_min = clip_rect ? &clip_rect->Min : &pos_min;
const ImVec2* clip_max = clip_rect ? &clip_rect->Max : &pos_max;
bool need_clipping = (pos.x + text_size.x >= clip_max->x) || (pos.y + text_size.y >= clip_max->y);
if (clip_rect) // If we had no explicit clipping rectangle then pos==clip_min
need_clipping |= (pos.x < clip_min->x) || (pos.y < clip_min->y);
// Align whole block. We should defer that to the better rendering function when we'll have support for individual line alignment.
if (align.x > 0.0f) pos.x = ImMax(pos.x, pos.x + (pos_max.x - pos.x - text_size.x) * align.x);
if (align.y > 0.0f) pos.y = ImMax(pos.y, pos.y + (pos_max.y - pos.y - text_size.y) * align.y);
// Render
if (need_clipping)
{
ImVec4 fine_clip_rect(clip_min->x, clip_min->y, clip_max->x, clip_max->y);
draw_list->AddText(NULL, 0.0f, pos, GetColorU32(ImGuiCol_Text), text, text_display_end, 0.0f, &fine_clip_rect);
}
else
{
draw_list->AddText(NULL, 0.0f, pos, GetColorU32(ImGuiCol_Text), text, text_display_end, 0.0f, NULL);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq 0x88(%rsp), %rbp
movq (%rsi), %r15
movq %r15, 0x10(%rsp)
movd %r15d, %xmm7
shrq $0x20, %r15
testq %r9, %r9
je 0x276f3
movsd (%r9), %xmm0
jmp 0x2770f
xorps %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movdqa %xmm7, 0x20(%rsp)
callq 0x27865
movdqa 0x20(%rsp), %xmm7
movd %r15d, %xmm2
leaq 0x8(%rbp), %rax
testq %rbp, %rbp
cmovneq %rbp, %r12
cmoveq %r13, %rax
movaps %xmm0, %xmm3
addss %xmm7, %xmm3
movss (%rax), %xmm1
movb $0x1, %cl
ucomiss %xmm1, %xmm3
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3 # xmm3 = xmm3[1,1],xmm0[1,1]
jae 0x2774a
movaps %xmm3, %xmm4
addss %xmm2, %xmm4
ucomiss 0x4(%rax), %xmm4
setae %cl
movq 0x80(%rsp), %rdx
testq %rbp, %rbp
je 0x27773
movss (%rbp), %xmm4
movb $0x1, %sil
ucomiss %xmm7, %xmm4
ja 0x27770
movss 0x4(%rbp), %xmm4
ucomiss %xmm2, %xmm4
seta %sil
orb %sil, %cl
movss (%rdx), %xmm5
xorps %xmm4, %xmm4
ucomiss %xmm4, %xmm5
jbe 0x277af
movss (%r13), %xmm6
subss %xmm7, %xmm6
subss %xmm0, %xmm6
mulss %xmm5, %xmm6
addss %xmm7, %xmm6
movaps %xmm6, %xmm0
cmpless %xmm7, %xmm0
movaps %xmm0, %xmm5
andnps %xmm6, %xmm5
andps %xmm7, %xmm0
orps %xmm5, %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x4(%rdx), %xmm0
ucomiss %xmm4, %xmm0
jbe 0x277e9
movss 0x4(%r13), %xmm4
subss %xmm2, %xmm4
subss %xmm3, %xmm4
mulss %xmm0, %xmm4
addss %xmm2, %xmm4
movaps %xmm4, %xmm0
cmpless %xmm2, %xmm0
movaps %xmm0, %xmm3
andnps %xmm4, %xmm3
andps %xmm2, %xmm0
orps %xmm3, %xmm0
movss %xmm0, 0x14(%rsp)
testb %cl, %cl
je 0x27823
movss 0x4(%rax), %xmm0
movsd (%r12), %xmm2
leaq 0x38(%rsp), %r15
movsd %xmm2, (%r15)
movss %xmm1, 0x8(%r15)
movss %xmm0, 0xc(%r15)
movss 0x75bbe(%rip), %xmm0 # 0x9d3d4
xorl %edi, %edi
callq 0x26fc5
movq %r15, (%rsp)
jmp 0x27837
movss 0x75ba9(%rip), %xmm0 # 0x9d3d4
xorl %edi, %edi
callq 0x26fc5
andq $0x0, (%rsp)
leaq 0x10(%rsp), %rdx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
movq 0x18(%rsp), %rdi
xorl %esi, %esi
movl %eax, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x4fff0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::CalcTextSize(char const*, char const*, bool, float) | ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
ImGuiContext& g = *GImGui;
const char* text_display_end;
if (hide_text_after_double_hash)
text_display_end = FindRenderedTextEnd(text, text_end); // Hide anything after a '##' string
else
text_display_end = text_end;
ImFont* font = g.Font;
const float font_size = g.FontSize;
if (text == text_display_end)
return ImVec2(0.0f, font_size);
ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);
// Round
// FIXME: This has been here since Dec 2015 (7b0bf230) but down the line we want this out.
// FIXME: Investigate using ceilf or e.g.
// - https://git.musl-libc.org/cgit/musl/tree/src/math/ceilf.c
// - https://embarkstudios.github.io/rust-gpu/api/src/libm/math/ceilf.rs.html
text_size.x = IM_FLOOR(text_size.x + 0.99999f);
return text_size;
} | pushq %r14
pushq %rbx
pushq %rax
movaps %xmm0, %xmm2
movq %rsi, %rax
movq %rdi, %rbx
movq 0xb5c5f(%rip), %r14 # 0xdd4d8
testl %edx, %edx
je 0x27894
movq %rbx, %rdi
movq %rax, %rsi
movss %xmm2, 0x4(%rsp)
callq 0x27372
movss 0x4(%rsp), %xmm2
movss 0x1a88(%r14), %xmm0
cmpq %rbx, %rax
je 0x278d7
movq 0x1a80(%r14), %rdi
movss 0x75b1f(%rip), %xmm1 # 0x9d3d0
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x567dc
movss 0x75b32(%rip), %xmm1 # 0x9d3f8
addss %xmm0, %xmm1
cvttps2dq %xmm1, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1,2,3]
jmp 0x278e2
movq %xmm0, %xmm0 # xmm0 = xmm0[0],zero
xorps %xmm1, %xmm1
shufps $0xe2, %xmm1, %xmm0 # xmm0 = xmm0[2,0],xmm1[2,3]
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::GetMouseDragDelta(int, float) | ImVec2 ImGui::GetMouseDragDelta(ImGuiMouseButton button, float lock_threshold)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
if (lock_threshold < 0.0f)
lock_threshold = g.IO.MouseDragThreshold;
if (g.IO.MouseDown[button] || g.IO.MouseReleased[button])
if (g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold)
if (IsMousePosValid(&g.IO.MousePos) && IsMousePosValid(&g.IO.MouseClickedPos[button]))
return g.IO.MousePos - g.IO.MouseClickedPos[button];
return ImVec2(0.0f, 0.0f);
} | pushq %r15
pushq %r14
pushq %rbx
cmpl $0x5, %edi
jae 0x34229
movq 0xa9336(%rip), %r14 # 0xdd4d8
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x341b0
movss 0x38(%r14), %xmm0
movl %edi, %r15d
cmpb $0x0, 0x128(%r14,%r15)
jne 0x341cc
xorps %xmm2, %xmm2
cmpb $0x1, 0x42a(%r14,%r15)
jne 0x34220
movss 0x490(%r14,%r15,4), %xmm1
mulss %xmm0, %xmm0
xorps %xmm2, %xmm2
ucomiss %xmm0, %xmm1
jb 0x34220
leaq 0x120(%r14), %rbx
movq %rbx, %rdi
callq 0x29bae
testb %al, %al
je 0x3421d
leaq (%r14,%r15,8), %r14
addq $0x3cc, %r14 # imm = 0x3CC
movq %r14, %rdi
callq 0x29bae
testb %al, %al
xorps %xmm2, %xmm2
je 0x34220
movsd (%rbx), %xmm2
movsd (%r14), %xmm0
subps %xmm0, %xmm2
jmp 0x34220
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6aa63(%rip), %rdi # 0x9ec93
leaq 0x69b5a(%rip), %rsi # 0x9dd91
leaq 0x6ac17(%rip), %rcx # 0x9ee55
movl $0x13f5, %edx # imm = 0x13F5
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetItemAllowOverlap() | void ImGui::SetItemAllowOverlap()
{
ImGuiContext& g = *GImGui;
ImGuiID id = g.LastItemData.ID;
if (g.HoveredId == id)
g.HoveredIdAllowOverlap = true;
if (g.ActiveId == id)
g.ActiveIdAllowOverlap = true;
} | movq 0xa90ac(%rip), %rax # 0xdd4d8
movl 0x1dd8(%rax), %ecx
cmpl %ecx, 0x1d58(%rax)
jne 0x34441
movb $0x1, 0x1d60(%rax)
cmpl %ecx, 0x1d6c(%rax)
jne 0x34450
movb $0x1, 0x1d79(%rax)
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::BeginGroup() | void ImGui::BeginGroup()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
g.GroupStack.resize(g.GroupStack.Size + 1);
ImGuiGroupData& group_data = g.GroupStack.back();
group_data.WindowID = window->ID;
group_data.BackupCursorPos = window->DC.CursorPos;
group_data.BackupCursorMaxPos = window->DC.CursorMaxPos;
group_data.BackupIndent = window->DC.Indent;
group_data.BackupGroupOffset = window->DC.GroupOffset;
group_data.BackupCurrLineSize = window->DC.CurrLineSize;
group_data.BackupCurrLineTextBaseOffset = window->DC.CurrLineTextBaseOffset;
group_data.BackupActiveIdIsAlive = g.ActiveIdIsAlive;
group_data.BackupHoveredIdIsAlive = g.HoveredId != 0;
group_data.BackupActiveIdPreviousFrameIsAlive = g.ActiveIdPreviousFrameIsAlive;
group_data.EmitItem = true;
window->DC.GroupOffset.x = window->DC.CursorPos.x - window->Pos.x - window->DC.ColumnsOffset.x;
window->DC.Indent = window->DC.GroupOffset;
window->DC.CursorMaxPos = window->DC.CursorPos;
window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
if (g.LogEnabled)
g.LogLinePosY = -FLT_MAX; // To enforce a carriage return
} | pushq %r15
pushq %r14
pushq %rbx
movq 0xa4552(%rip), %r14 # 0xdd4d8
movq 0x1d18(%r14), %r15
leaq 0x1ef8(%r14), %rbx
movl 0x1ef8(%r14), %esi
incl %esi
movq %rbx, %rdi
callq 0x49b1a
movq %rbx, %rdi
callq 0x4a6ca
movl 0x8(%r15), %ecx
movl %ecx, (%rax)
movq 0x110(%r15), %rcx
movq %rcx, 0x4(%rax)
movq 0x128(%r15), %rcx
movq %rcx, 0xc(%rax)
movl 0x150(%r15), %ecx
movl %ecx, 0x14(%rax)
movl 0x158(%r15), %ecx
movl %ecx, 0x18(%rax)
movq 0x138(%r15), %rcx
movq %rcx, 0x1c(%rax)
movss 0x148(%r15), %xmm0
movss %xmm0, 0x24(%rax)
movl 0x1d70(%r14), %ecx
movl %ecx, 0x28(%rax)
cmpl $0x0, 0x1d58(%r14)
setne 0x2d(%rax)
movb 0x1dac(%r14), %cl
movb %cl, 0x2c(%rax)
movb $0x1, 0x2e(%rax)
movss 0x110(%r15), %xmm0
subss 0x48(%r15), %xmm0
subss 0x154(%r15), %xmm0
movss %xmm0, 0x158(%r15)
movss %xmm0, 0x150(%r15)
movq 0x110(%r15), %rax
movq %rax, 0x128(%r15)
andq $0x0, 0x138(%r15)
cmpb $0x1, 0x32b4(%r14)
jne 0x3906f
movl $0xff7fffff, 0x32e8(%r14) # imm = 0xFF7FFFFF
popq %rbx
popq %r14
popq %r15
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetScrollFromPosX(ImGuiWindow*, float, float) | void ImGui::SetScrollFromPosX(ImGuiWindow* window, float local_x, float center_x_ratio)
{
IM_ASSERT(center_x_ratio >= 0.0f && center_x_ratio <= 1.0f);
window->ScrollTarget.x = IM_FLOOR(local_x + window->Scroll.x); // Convert local position to scroll offset
window->ScrollTargetCenterRatio.x = center_x_ratio;
window->ScrollTargetEdgeSnapDist.x = 0.0f;
} | xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jb 0x390d2
movss 0x6432e(%rip), %xmm2 # 0x9d3d4
ucomiss %xmm1, %xmm2
jb 0x390d2
addss 0x94(%rdi), %xmm0
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xa4(%rdi)
movss %xmm1, 0xac(%rdi)
andl $0x0, 0xb4(%rdi)
retq
pushq %rax
leaq 0x672e0(%rip), %rdi # 0xa03ba
leaq 0x64cb0(%rip), %rsi # 0x9dd91
leaq 0x67303(%rip), %rcx # 0xa03eb
movl $0x2241, %edx # imm = 0x2241
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetScrollFromPosY(ImGuiWindow*, float, float) | void ImGui::SetScrollFromPosY(ImGuiWindow* window, float local_y, float center_y_ratio)
{
IM_ASSERT(center_y_ratio >= 0.0f && center_y_ratio <= 1.0f);
const float decoration_up_height = window->TitleBarHeight() + window->MenuBarHeight(); // FIXME: Would be nice to have a more standardized access to our scrollable/client rect;
local_y -= decoration_up_height;
window->ScrollTarget.y = IM_FLOOR(local_y + window->Scroll.y); // Convert local position to scroll offset
window->ScrollTargetCenterRatio.y = center_y_ratio;
window->ScrollTargetEdgeSnapDist.y = 0.0f;
} | pushq %rbx
subq $0x20, %rsp
movaps %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jb 0x3916e
movss 0x642c8(%rip), %xmm0 # 0x9d3d4
ucomiss %xmm1, %xmm0
jb 0x3916e
movq %rdi, %rbx
movss %xmm1, 0xc(%rsp)
callq 0x4a228
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4a252
addss 0x8(%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
subss %xmm0, %xmm1
addss 0x98(%rbx), %xmm1
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0xa8(%rbx)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0xb0(%rbx)
andl $0x0, 0xb8(%rbx)
addq $0x20, %rsp
popq %rbx
retq
leaq 0x672b1(%rip), %rdi # 0xa0426
leaq 0x64c15(%rip), %rsi # 0x9dd91
leaq 0x672d4(%rip), %rcx # 0xa0457
movl $0x2249, %edx # imm = 0x2249
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetScrollHereX(float) | void ImGui::SetScrollHereX(float center_x_ratio)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
float spacing_x = ImMax(window->WindowPadding.x, g.Style.ItemSpacing.x);
float target_pos_x = ImLerp(g.LastItemData.Rect.Min.x - spacing_x, g.LastItemData.Rect.Max.x + spacing_x, center_x_ratio);
SetScrollFromPosX(window, target_pos_x - window->Pos.x, center_x_ratio); // Convert from absolute to local pos
// Tweak: snap on edges when aiming at an item very close to the edge
window->ScrollTargetEdgeSnapDist.x = ImMax(0.0f, window->WindowPadding.x - spacing_x);
} | pushq %rbx
subq $0x10, %rsp
movaps %xmm0, %xmm1
movq 0xa4242(%rip), %rax # 0xdd4d8
movq 0x1d18(%rax), %rbx
movss 0x78(%rbx), %xmm0
movss 0x168c(%rax), %xmm2
movaps %xmm2, %xmm3
cmpless %xmm0, %xmm3
andps %xmm3, %xmm0
andnps %xmm2, %xmm3
orps %xmm0, %xmm3
movaps %xmm3, (%rsp)
movss 0x1de4(%rax), %xmm2
subss %xmm3, %xmm2
movss 0x1dec(%rax), %xmm0
addss %xmm3, %xmm0
subss %xmm2, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
subss 0x48(%rbx), %xmm0
movq %rbx, %rdi
callq 0x39096
movss 0x78(%rbx), %xmm0
subss (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm0, %xmm2
cmpless %xmm1, %xmm2
andnps %xmm0, %xmm2
movss %xmm2, 0xb4(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::BeginTooltipEx(int, int) | void ImGui::BeginTooltipEx(ImGuiWindowFlags extra_flags, ImGuiTooltipFlags tooltip_flags)
{
ImGuiContext& g = *GImGui;
if (g.DragDropWithinSource || g.DragDropWithinTarget)
{
// The default tooltip position is a little offset to give space to see the context menu (it's also clamped within the current viewport/monitor)
// In the context of a dragging tooltip we try to reduce that offset and we enforce following the cursor.
// Whatever we do we want to call SetNextWindowPos() to enforce a tooltip position and disable clipping the tooltip without our display area, like regular tooltip do.
//ImVec2 tooltip_pos = g.IO.MousePos - g.ActiveIdClickOffset - g.Style.WindowPadding;
ImVec2 tooltip_pos = g.IO.MousePos + ImVec2(16 * g.Style.MouseCursorScale, 8 * g.Style.MouseCursorScale);
SetNextWindowPos(tooltip_pos);
SetNextWindowBgAlpha(g.Style.Colors[ImGuiCol_PopupBg].w * 0.60f);
//PushStyleVar(ImGuiStyleVar_Alpha, g.Style.Alpha * 0.60f); // This would be nice but e.g ColorButton with checkboard has issue with transparent colors :(
tooltip_flags |= ImGuiTooltipFlags_OverridePreviousTooltip;
}
char window_name[16];
ImFormatString(window_name, IM_ARRAYSIZE(window_name), "##Tooltip_%02d", g.TooltipOverrideCount);
if (tooltip_flags & ImGuiTooltipFlags_OverridePreviousTooltip)
if (ImGuiWindow* window = FindWindowByName(window_name))
if (window->Active)
{
// Hide previous tooltip from being displayed. We can't easily "reset" the content of a window so we create a new one.
window->Hidden = true;
window->HiddenFramesCanSkipItems = 1; // FIXME: This may not be necessary?
ImFormatString(window_name, IM_ARRAYSIZE(window_name), "##Tooltip_%02d", ++g.TooltipOverrideCount);
}
ImGuiWindowFlags flags = ImGuiWindowFlags_Tooltip | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDocking;
Begin(window_name, NULL, flags | extra_flags);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movq 0xa4116(%rip), %r14 # 0xdd4d8
cmpb $0x0, 0x20fd(%r14)
jne 0x393d8
movl %esi, %ebp
cmpb $0x1, 0x20fe(%r14)
jne 0x3943f
movss 0x16f8(%r14), %xmm0
unpcklps %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
mulps 0x63ec5(%rip), %xmm0 # 0x9d2b0
movsd 0x120(%r14), %xmm1
addps %xmm0, %xmm1
movlps %xmm1, 0x1e2c(%r14)
andq $0x0, 0x1e34(%r14)
movl $0x1, 0x1e1c(%r14)
movb $0x1, 0x1e54(%r14)
movss 0x1754(%r14), %xmm0
orb $0x41, 0x1e18(%r14)
mulss 0x64055(%rip), %xmm0 # 0x9d488
movss %xmm0, 0x1e78(%r14)
pushq $0x1
popq %rbp
movswl 0x31d6(%r14), %ecx
leaq 0x67044(%rip), %rdx # 0xa0492
movq %rsp, %rdi
pushq $0x10
popq %rsi
xorl %eax, %eax
callq 0x259dd
testb $0x1, %bpl
je 0x394ae
movq %rsp, %rdi
callq 0x34ede
testq %rax, %rax
je 0x394ae
cmpb $0x1, 0xc7(%rax)
jne 0x394ae
movb $0x1, %cl
movb %cl, 0xce(%rax)
movb %cl, 0xe8(%rax)
movzwl 0x31d6(%r14), %eax
incl %eax
movw %ax, 0x31d6(%r14)
movswl %ax, %ecx
leaq 0x66ff1(%rip), %rdx # 0xa0492
movq %rsp, %rdi
pushq $0x10
popq %rsi
xorl %eax, %eax
callq 0x259dd
orl $0x22c0347, %ebx # imm = 0x22C0347
movq %rsp, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x2e31a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::NavCalcPreferredRefPos() | static ImVec2 ImGui::NavCalcPreferredRefPos()
{
ImGuiContext& g = *GImGui;
if (g.NavDisableHighlight || !g.NavDisableMouseHover || !g.NavWindow)
{
// Mouse (we need a fallback in case the mouse becomes invalid after being used)
if (IsMousePosValid(&g.IO.MousePos))
return g.IO.MousePos;
return g.MouseLastValidPos;
}
else
{
// When navigation is active and mouse is disabled, decide on an arbitrary position around the bottom left of the currently navigated item.
const ImRect& rect_rel = g.NavWindow->NavRectRel[g.NavLayer];
ImVec2 pos = g.NavWindow->Pos + ImVec2(rect_rel.Min.x + ImMin(g.Style.FramePadding.x * 4, rect_rel.GetWidth()), rect_rel.Max.y - ImMin(g.Style.FramePadding.y, rect_rel.GetHeight()));
ImGuiViewport* viewport = g.NavWindow->Viewport;
return ImFloor(ImClamp(pos, viewport->Pos, viewport->Pos + viewport->Size)); // ImFloor() is important because non-integer mouse position application in backend might be lossy and result in undesirable non-zero delta.
}
} | pushq %r14
pushq %rbx
pushq %rax
movq 0xa3e0f(%rip), %r14 # 0xdd4d8
cmpb $0x0, 0x1fd2(%r14)
jne 0x39777
cmpb $0x1, 0x1fd3(%r14)
jne 0x39777
movq 0x1f88(%r14), %rax
testq %rax, %rax
je 0x39777
movl 0x1fc8(%r14), %ecx
shlq $0x4, %rcx
movss 0x167c(%r14), %xmm0
mulss 0x63d3b(%rip), %xmm0 # 0x9d44c
movsd 0x3b8(%rax,%rcx), %xmm1
movsd 0x3c0(%rax,%rcx), %xmm2
movaps %xmm2, %xmm3
subps %xmm1, %xmm3
movss 0x1680(%r14), %xmm4
unpcklps %xmm4, %xmm0 # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
minps %xmm3, %xmm0
addps %xmm0, %xmm1
subps %xmm0, %xmm2
shufps $0x1, %xmm1, %xmm2 # xmm2 = xmm2[1,0],xmm1[0,0]
shufps $0xe2, %xmm1, %xmm2 # xmm2 = xmm2[2,0],xmm1[2,3]
movsd 0x48(%rax), %xmm0
addps %xmm2, %xmm0
movq %rsp, %rdi
movlps %xmm0, (%rdi)
movq 0x30(%rax), %rax
leaq 0x8(%rax), %rsi
movsd 0x8(%rax), %xmm1
movsd 0x10(%rax), %xmm0
addps %xmm1, %xmm0
callq 0x3a183
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
jmp 0x39799
leaq 0x120(%r14), %rbx
movq %rbx, %rdi
callq 0x29bae
testb %al, %al
je 0x39790
movsd (%rbx), %xmm0
jmp 0x39799
movsd 0x2258(%r14), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::ClosePopupToLevel(int, bool) | void ImGui::ClosePopupToLevel(int remaining, bool restore_focus_to_window_under_popup)
{
ImGuiContext& g = *GImGui;
IMGUI_DEBUG_LOG_POPUP("ClosePopupToLevel(%d), restore_focus_to_window_under_popup=%d\n", remaining, restore_focus_to_window_under_popup);
IM_ASSERT(remaining >= 0 && remaining < g.OpenPopupStack.Size);
// Trim open popup stack
ImGuiWindow* focus_window = g.OpenPopupStack[remaining].SourceWindow;
ImGuiWindow* popup_window = g.OpenPopupStack[remaining].Window;
g.OpenPopupStack.resize(remaining);
if (restore_focus_to_window_under_popup)
{
if (focus_window && !focus_window->WasActive && popup_window)
{
// Fallback
FocusTopMostWindowUnderOne(popup_window, NULL);
}
else
{
if (g.NavLayer == ImGuiNavLayer_Main && focus_window)
focus_window = NavRestoreLastChildNavWindow(focus_window);
FocusWindow(focus_window);
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x3986b
movl %edi, %r14d
movq 0xa3d1a(%rip), %r13 # 0xdd4d8
cmpl %edi, 0x1f08(%r13)
jle 0x3986b
movl %esi, %ebp
leaq 0x1f08(%r13), %r12
movq %r12, %rdi
movl %r14d, %esi
callq 0x4a100
movq 0x10(%rax), %rbx
movq %r12, %rdi
movl %r14d, %esi
callq 0x4a100
movq 0x8(%rax), %r15
movq %r12, %rdi
movl %r14d, %esi
callq 0x49a50
testb %bpl, %bpl
je 0x3982d
testq %rbx, %rbx
je 0x3983c
cmpb $0x0, 0xc8(%rbx)
jne 0x39840
testq %r15, %r15
je 0x39840
movq %r15, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e12b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x39855
cmpl $0x0, 0x1fc8(%r13)
jne 0x39855
movq %rbx, %rdi
callq 0x36e6b
movq %rax, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29629
leaq 0x66db1(%rip), %rdi # 0xa0623
leaq 0x64518(%rip), %rsi # 0x9dd91
leaq 0x66dd7(%rip), %rcx # 0xa0657
movl $0x236b, %edx # imm = 0x236B
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::ClosePopupsExceptModals() | void ImGui::ClosePopupsExceptModals()
{
ImGuiContext& g = *GImGui;
int popup_count_to_keep;
for (popup_count_to_keep = g.OpenPopupStack.Size; popup_count_to_keep > 0; popup_count_to_keep--)
{
ImGuiWindow* window = g.OpenPopupStack[popup_count_to_keep - 1].Window;
if (!window || window->Flags & ImGuiWindowFlags_Modal)
break;
}
if (popup_count_to_keep < g.OpenPopupStack.Size) // This test is not required but it allows to set a convenient breakpoint on the statement below
ClosePopupToLevel(popup_count_to_keep, true);
} | pushq %rbp
pushq %r14
pushq %rbx
movq 0xa3c43(%rip), %rbx # 0xdd4d8
movl 0x1f08(%rbx), %ebp
addq $0x1f08, %rbx # imm = 0x1F08
movl %ebp, %r14d
testl %ebp, %ebp
jle 0x398c6
leal -0x1(%r14), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4a100
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x398c6
testb $0x8, 0xf(%rax)
je 0x398a2
cmpl (%rbx), %r14d
jge 0x398da
pushq $0x1
popq %rsi
movl %r14d, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x397a1
popq %rbx
popq %r14
popq %rbp
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::SetNavID(unsigned int, ImGuiNavLayer, unsigned int, ImRect const&) | void ImGui::SetNavID(ImGuiID id, ImGuiNavLayer nav_layer, ImGuiID focus_scope_id, const ImRect& rect_rel)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.NavWindow != NULL);
IM_ASSERT(nav_layer == ImGuiNavLayer_Main || nav_layer == ImGuiNavLayer_Menu);
g.NavId = id;
g.NavLayer = nav_layer;
g.NavFocusScopeId = focus_scope_id;
g.NavWindow->NavLastIds[nav_layer] = id;
g.NavWindow->NavRectRel[nav_layer] = rect_rel;
//g.NavDisableHighlight = false;
//g.NavDisableMouseHover = g.NavMousePosDirty = true;
} | pushq %rax
movq 0xa32af(%rip), %r8 # 0xdd4d8
movq 0x1f88(%r8), %rax
testq %rax, %rax
je 0x3a269
cmpl $0x2, %esi
jae 0x3a288
movl %edi, 0x1f90(%r8)
movl %esi, 0x1fc8(%r8)
movl %edx, 0x1f94(%r8)
movl %esi, %edx
movl %edi, 0x3b0(%rax,%rdx,4)
shlq $0x4, %rdx
movups (%rcx), %xmm0
movups %xmm0, 0x3b8(%rax,%rdx)
popq %rax
retq
leaq 0x66556(%rip), %rdi # 0xa07c6
leaq 0x63b1a(%rip), %rsi # 0x9dd91
leaq 0x6655e(%rip), %rcx # 0xa07dc
movl $0x24d8, %edx # imm = 0x24D8
callq 0x24110
leaq 0x66593(%rip), %rdi # 0xa0822
leaq 0x63afb(%rip), %rsi # 0x9dd91
leaq 0x6653f(%rip), %rcx # 0xa07dc
movl $0x24d9, %edx # imm = 0x24D9
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::NavInitRequestApplyResult() | void ImGui::NavInitRequestApplyResult()
{
// In very rare cases g.NavWindow may be null (e.g. clearing focus after requesting an init request, which does happen when releasing Alt while clicking on void)
ImGuiContext& g = *GImGui;
if (!g.NavWindow)
return;
// Apply result from previous navigation init request (will typically select the first item, unless SetItemDefaultFocus() has been called)
// FIXME-NAV: On _NavFlattened windows, g.NavWindow will only be updated during subsequent frame. Not a problem currently.
IMGUI_DEBUG_LOG_NAV("[nav] NavInitRequest: result NavID 0x%08X in Layer %d Window \"%s\"\n", g.NavInitResultId, g.NavLayer, g.NavWindow->Name);
SetNavID(g.NavInitResultId, g.NavLayer, 0, g.NavInitResultRectRel);
g.NavIdIsAlive = true; // Mark as alive from previous frame as we got a result
if (g.NavInitRequestFromMove)
{
g.NavDisableHighlight = false;
g.NavDisableMouseHover = g.NavMousePosDirty = true;
}
} | pushq %rbx
movq 0xa2db8(%rip), %rbx # 0xdd4d8
cmpq $0x0, 0x1f88(%rbx)
je 0x3a764
movl 0x1fc8(%rbx), %esi
movl 0x1fd8(%rbx), %edi
leaq 0x1fdc(%rbx), %rcx
xorl %edx, %edx
callq 0x3a221
movb $0x1, 0x1fd0(%rbx)
cmpb $0x1, 0x1fd6(%rbx)
jne 0x3a764
movw $0x1, 0x1fd1(%rbx)
movb $0x1, 0x1fd3(%rbx)
popq %rbx
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::BeginDragDropTarget() | bool ImGui::BeginDragDropTarget()
{
ImGuiContext& g = *GImGui;
if (!g.DragDropActive)
return false;
ImGuiWindow* window = g.CurrentWindow;
if (!(g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HoveredRect))
return false;
ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWindow;
if (hovered_window == NULL || window->RootWindowDockTree != hovered_window->RootWindowDockTree || window->SkipItems)
return false;
const ImRect& display_rect = (g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HasDisplayRect) ? g.LastItemData.DisplayRect : g.LastItemData.Rect;
ImGuiID id = g.LastItemData.ID;
if (id == 0)
id = window->GetIDFromRectangle(display_rect);
if (g.DragDropPayload.SourceId == id)
return false;
IM_ASSERT(g.DragDropWithinTarget == false);
g.DragDropTargetRect = display_rect;
g.DragDropTargetId = id;
g.DragDropWithinTarget = true;
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq 0xa2575(%rip), %r14 # 0xdd4d8
cmpb $0x1, 0x20fc(%r14)
jne 0x3afd1
movl 0x1de0(%r14), %eax
testb $0x1, %al
je 0x3afd1
movq 0x1d28(%r14), %rcx
testq %rcx, %rcx
je 0x3afd1
movq 0x1d18(%r14), %rdi
movq 0x390(%rdi), %rdx
cmpq 0x390(%rcx), %rdx
jne 0x3afd1
cmpb $0x0, 0xcc(%rdi)
jne 0x3afd1
andl $0x2, %eax
shll $0x4, %eax
leaq (%rax,%r14), %rbx
addq $0x1de4, %rbx # imm = 0x1DE4
movl 0x1dd8(%r14), %eax
testl %eax, %eax
jne 0x3afc8
movq %rbx, %rsi
callq 0x28674
cmpl %eax, 0x211c(%r14)
jne 0x3afdb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x0, 0x20fe(%r14)
jne 0x3b003
movups (%rbx), %xmm0
movups %xmm0, 0x2150(%r14)
movl %eax, 0x2160(%r14)
movb $0x1, 0x20fe(%r14)
movb $0x1, %al
jmp 0x3afd3
leaq 0x65ca7(%rip), %rdi # 0xa0cb1
leaq 0x62d80(%rip), %rsi # 0x9dd91
leaq 0x65cb9(%rip), %rcx # 0xa0cd1
movl $0x2af7, %edx # imm = 0x2AF7
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::AcceptDragDropPayload(char const*, int) | const ImGuiPayload* ImGui::AcceptDragDropPayload(const char* type, ImGuiDragDropFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiPayload& payload = g.DragDropPayload;
IM_ASSERT(g.DragDropActive); // Not called between BeginDragDropTarget() and EndDragDropTarget() ?
IM_ASSERT(payload.DataFrameCount != -1); // Forgot to call EndDragDropTarget() ?
if (type != NULL && !payload.IsDataType(type))
return NULL;
// Accept smallest drag target bounding box, this allows us to nest drag targets conveniently without ordering constraints.
// NB: We currently accept NULL id as target. However, overlapping targets requires a unique ID to function!
const bool was_accepted_previously = (g.DragDropAcceptIdPrev == g.DragDropTargetId);
ImRect r = g.DragDropTargetRect;
float r_surface = r.GetWidth() * r.GetHeight();
if (r_surface <= g.DragDropAcceptIdCurrRectSurface)
{
g.DragDropAcceptFlags = flags;
g.DragDropAcceptIdCurr = g.DragDropTargetId;
g.DragDropAcceptIdCurrRectSurface = r_surface;
}
// Render default drop visuals
// FIXME-DRAGDROP: Settle on a proper default visuals for drop target.
payload.Preview = was_accepted_previously;
flags |= (g.DragDropSourceFlags & ImGuiDragDropFlags_AcceptNoDrawDefaultRect); // Source can also inhibit the preview (useful for external sources that lives for 1 frame)
if (!(flags & ImGuiDragDropFlags_AcceptNoDrawDefaultRect) && payload.Preview)
window->DrawList->AddRect(r.Min - ImVec2(3.5f,3.5f), r.Max + ImVec2(3.5f, 3.5f), GetColorU32(ImGuiCol_DragDropTarget), 0.0f, 0, 2.0f);
g.DragDropAcceptFrameCount = g.FrameCount;
payload.Delivery = was_accepted_previously && !IsMouseDown(g.DragDropMouseButton); // For extern drag sources affecting os window focus, it's easier to just test !IsMouseDown() instead of IsMouseReleased()
if (!payload.Delivery && !(flags & ImGuiDragDropFlags_AcceptBeforeDelivery))
return NULL;
return &payload;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0xa24a1(%rip), %r13 # 0xdd4d8
cmpb $0x0, 0x20fc(%r13)
je 0x3b1a7
cmpl $-0x1, 0x2124(%r13)
je 0x3b1c6
movl %esi, %ebp
movq %rdi, %rsi
movq 0x1d18(%r13), %r14
leaq 0x2110(%r13), %rbx
testq %rdi, %rdi
je 0x3b07b
movq %rbx, %rdi
callq 0x4a7be
testb %al, %al
je 0x3b183
movl 0x2170(%r13), %r15d
movl 0x2160(%r13), %r12d
cmpl %r12d, %r15d
sete %al
movsd 0x2150(%r13), %xmm1
movsd 0x2158(%r13), %xmm0
movaps %xmm0, %xmm3
subps %xmm1, %xmm3
movaps %xmm3, %xmm2
shufps $0x55, %xmm3, %xmm2 # xmm2 = xmm2[1,1],xmm3[1,1]
mulss %xmm3, %xmm2
movss 0x2168(%r13), %xmm3
ucomiss %xmm2, %xmm3
jb 0x3b0d7
movl %ebp, 0x2164(%r13)
movl %r12d, 0x216c(%r13)
movss %xmm2, 0x2168(%r13)
movl %r15d, %ecx
xorl %r12d, %ecx
movb %al, 0x2149(%r13)
movl 0x2100(%r13), %eax
orl %ebp, %eax
andl $0x800, %eax # imm = 0x800
orl %ecx, %eax
jne 0x3b14d
movq 0x2a8(%r14), %r14
addps 0x621cc(%rip), %xmm1 # 0x9d2d0
leaq 0x10(%rsp), %rax
movlps %xmm1, (%rax)
addps 0x621cd(%rip), %xmm0 # 0x9d2e0
leaq 0x8(%rsp), %rax
movlps %xmm0, (%rax)
pushq $0x32
popq %rdi
movss 0x622ae(%rip), %xmm0 # 0x9d3d4
callq 0x26fc5
movss 0x622c9(%rip), %xmm1 # 0x9d3fc
xorps %xmm0, %xmm0
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x4f94e
movl 0x1c98(%r13), %eax
movl %eax, 0x2174(%r13)
cmpl %r12d, %r15d
jne 0x3b197
movl 0x2108(%r13), %edi
callq 0x337ca
movl %eax, %ecx
xorb $0x1, %cl
movb %cl, 0x214a(%r13)
btl $0xa, %ebp
setae %cl
testb %al, %cl
je 0x3b185
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, 0x214a(%r13)
btl $0xa, %ebp
jae 0x3b183
jmp 0x3b185
leaq 0x6339f(%rip), %rdi # 0x9e54d
leaq 0x62bdc(%rip), %rsi # 0x9dd91
leaq 0x65b37(%rip), %rcx # 0xa0cf3
movl $0x2b09, %edx # imm = 0x2B09
callq 0x24110
leaq 0x65b79(%rip), %rdi # 0xa0d46
leaq 0x62bbd(%rip), %rsi # 0x9dd91
leaq 0x65b18(%rip), %rcx # 0xa0cf3
movl $0x2b0a, %edx # imm = 0x2B0A
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::EndDragDropTarget() | void ImGui::EndDragDropTarget()
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.DragDropActive);
IM_ASSERT(g.DragDropWithinTarget);
g.DragDropWithinTarget = false;
} | pushq %rax
movq 0xa22cf(%rip), %rax # 0xdd4d8
cmpb $0x0, 0x20fc(%rax)
je 0x3b224
cmpb $0x0, 0x20fe(%rax)
je 0x3b243
movb $0x0, 0x20fe(%rax)
popq %rax
retq
leaq 0x63322(%rip), %rdi # 0x9e54d
leaq 0x62b5f(%rip), %rsi # 0x9dd91
leaq 0x65b2a(%rip), %rcx # 0xa0d63
movl $0x2b33, %edx # imm = 0x2B33
callq 0x24110
leaq 0x65b39(%rip), %rdi # 0xa0d83
leaq 0x62b40(%rip), %rsi # 0x9dd91
leaq 0x65b0b(%rip), %rcx # 0xa0d63
movl $0x2b34, %edx # imm = 0x2B34
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::LogBegin(ImGuiLogType, int) | void ImGui::LogBegin(ImGuiLogType type, int auto_open_depth)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
IM_ASSERT(g.LogEnabled == false);
IM_ASSERT(g.LogFile == NULL);
IM_ASSERT(g.LogBuffer.empty());
g.LogEnabled = true;
g.LogType = type;
g.LogNextPrefix = g.LogNextSuffix = NULL;
g.LogDepthRef = window->DC.TreeDepth;
g.LogDepthToExpand = ((auto_open_depth >= 0) ? auto_open_depth : g.LogDepthToExpandDefault);
g.LogLinePosY = FLT_MAX;
g.LogLineFirstItem = true;
} | pushq %rax
movq 0xa2123(%rip), %rax # 0xdd4d8
cmpb $0x0, 0x32b4(%rax)
jne 0x3b422
cmpq $0x0, 0x32c0(%rax)
jne 0x3b441
cmpl $0x2, 0x32c8(%rax)
jge 0x3b460
movq 0x1d18(%rax), %rcx
movb $0x1, 0x32b4(%rax)
movl %edi, 0x32b8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x32d8(%rax)
movl 0x190(%rcx), %ecx
movl %ecx, 0x32f0(%rax)
testl %esi, %esi
jns 0x3b409
movl 0x32f8(%rax), %esi
movl %esi, 0x32f4(%rax)
movl $0x7f7fffff, 0x32e8(%rax) # imm = 0x7F7FFFFF
movb $0x1, 0x32ec(%rax)
popq %rax
retq
leaq 0x65979(%rip), %rdi # 0xa0da2
leaq 0x62961(%rip), %rsi # 0x9dd91
leaq 0x65981(%rip), %rcx # 0xa0db8
movl $0x2ba5, %edx # imm = 0x2BA5
callq 0x24110
leaq 0x65998(%rip), %rdi # 0xa0de0
leaq 0x62942(%rip), %rsi # 0x9dd91
leaq 0x65962(%rip), %rcx # 0xa0db8
movl $0x2ba6, %edx # imm = 0x2BA6
callq 0x24110
leaq 0x6598d(%rip), %rdi # 0xa0df4
leaq 0x62923(%rip), %rsi # 0x9dd91
leaq 0x65943(%rip), %rcx # 0xa0db8
movl $0x2ba7, %edx # imm = 0x2BA7
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::LogToTTY(int) | void ImGui::LogToTTY(int auto_open_depth)
{
ImGuiContext& g = *GImGui;
if (g.LogEnabled)
return;
IM_UNUSED(auto_open_depth);
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
LogBegin(ImGuiLogType_TTY, auto_open_depth);
g.LogFile = stdout;
#endif
} | pushq %rbx
movq 0xa203b(%rip), %rbx # 0xdd4d8
cmpb $0x0, 0x32b4(%rbx)
jne 0x3b4c1
movl %edi, %esi
pushq $0x1
popq %rdi
callq 0x3b3ad
movq 0xa1b21(%rip), %rax # 0xdcfd8
movq (%rax), %rax
movq %rax, 0x32c0(%rbx)
popq %rbx
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::DockSpace(unsigned int, ImVec2 const&, int, ImGuiWindowClass const*) | ImGuiID ImGui::DockSpace(ImGuiID id, const ImVec2& size_arg, ImGuiDockNodeFlags flags, const ImGuiWindowClass* window_class)
{
ImGuiContext* ctx = GImGui;
ImGuiContext& g = *ctx;
ImGuiWindow* window = GetCurrentWindow();
if (!(g.IO.ConfigFlags & ImGuiConfigFlags_DockingEnable))
return 0;
// Early out if parent window is hidden/collapsed
// This is faster but also DockNodeUpdateTabBar() relies on TabBarLayout() running (which won't if SkipItems=true) to set NextSelectedTabId = 0). See #2960.
// If for whichever reason this is causing problem we would need to ensure that DockNodeUpdateTabBar() ends up clearing NextSelectedTabId even if SkipItems=true.
if (window->SkipItems)
flags |= ImGuiDockNodeFlags_KeepAliveOnly;
IM_ASSERT((flags & ImGuiDockNodeFlags_DockSpace) == 0);
IM_ASSERT(id != 0);
ImGuiDockNode* node = DockContextFindNodeByID(ctx, id);
if (!node)
{
IMGUI_DEBUG_LOG_DOCKING("DockSpace: dockspace node 0x%08X created\n", id);
node = DockContextAddNode(ctx, id);
node->SetLocalFlags(ImGuiDockNodeFlags_CentralNode);
}
if (window_class && window_class->ClassId != node->WindowClass.ClassId)
IMGUI_DEBUG_LOG_DOCKING("DockSpace: dockspace node 0x%08X: setup WindowClass 0x%08X -> 0x%08X\n", id, node->WindowClass.ClassId, window_class->ClassId);
node->SharedFlags = flags;
node->WindowClass = window_class ? *window_class : ImGuiWindowClass();
// When a DockSpace transitioned form implicit to explicit this may be called a second time
// It is possible that the node has already been claimed by a docked window which appeared before the DockSpace() node, so we overwrite IsDockSpace again.
if (node->LastFrameActive == g.FrameCount && !(flags & ImGuiDockNodeFlags_KeepAliveOnly))
{
IM_ASSERT(node->IsDockSpace() == false && "Cannot call DockSpace() twice a frame with the same ID");
node->SetLocalFlags(node->LocalFlags | ImGuiDockNodeFlags_DockSpace);
return id;
}
node->SetLocalFlags(node->LocalFlags | ImGuiDockNodeFlags_DockSpace);
// Keep alive mode, this is allow windows docked into this node so stay docked even if they are not visible
if (flags & ImGuiDockNodeFlags_KeepAliveOnly)
{
node->LastFrameAlive = g.FrameCount;
return id;
}
const ImVec2 content_avail = GetContentRegionAvail();
ImVec2 size = ImFloor(size_arg);
if (size.x <= 0.0f)
size.x = ImMax(content_avail.x + size.x, 4.0f); // Arbitrary minimum child size (0.0f causing too much issues)
if (size.y <= 0.0f)
size.y = ImMax(content_avail.y + size.y, 4.0f);
IM_ASSERT(size.x > 0.0f && size.y > 0.0f);
node->Pos = window->DC.CursorPos;
node->Size = node->SizeRef = size;
SetNextWindowPos(node->Pos);
SetNextWindowSize(node->Size);
g.NextWindowData.PosUndock = false;
// FIXME-DOCK: Why do we need a child window to host a dockspace, could we host it in the existing window?
// FIXME-DOCK: What is the reason for not simply calling BeginChild()? (OK to have a reason but should be commented)
ImGuiWindowFlags window_flags = ImGuiWindowFlags_ChildWindow | ImGuiWindowFlags_DockNodeHost;
window_flags |= ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar;
window_flags |= ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse;
window_flags |= ImGuiWindowFlags_NoBackground;
char title[256];
ImFormatString(title, IM_ARRAYSIZE(title), "%s/DockSpace_%08X", window->Name, id);
PushStyleVar(ImGuiStyleVar_ChildBorderSize, 0.0f);
Begin(title, NULL, window_flags);
PopStyleVar();
ImGuiWindow* host_window = g.CurrentWindow;
DockNodeSetupHostWindow(node, host_window);
host_window->ChildId = window->GetID(title);
node->OnlyNodeWithWindows = NULL;
IM_ASSERT(node->IsRootNode());
// We need to handle the rare case were a central node is missing.
// This can happen if the node was first created manually with DockBuilderAddNode() but _without_ the ImGuiDockNodeFlags_Dockspace.
// Doing it correctly would set the _CentralNode flags, which would then propagate according to subsequent split.
// It would also be ambiguous to attempt to assign a central node while there are split nodes, so we wait until there's a single node remaining.
// The specific sub-property of _CentralNode we are interested in recovering here is the "Don't delete when empty" property,
// as it doesn't make sense for an empty dockspace to not have this property.
if (node->IsLeafNode() && !node->IsCentralNode())
node->SetLocalFlags(node->LocalFlags | ImGuiDockNodeFlags_CentralNode);
// Update the node
DockNodeUpdate(node);
End();
ItemSize(size);
return id;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq 0x9d3fa(%rip), %r12 # 0xdd4d8
movq 0x1d18(%r12), %r15
movb $0x1, 0xc9(%r15)
xorl %eax, %eax
testb $0x40, 0x8(%r12)
je 0x403c4
btl $0xa, %edx
jb 0x403d6
movl %edi, %ebx
movq %rsi, 0x8(%rsp)
testl %edi, %edi
je 0x403f5
movq %rcx, %rbp
movzbl 0xcc(%r15), %r13d
orl %edx, %r13d
leaq 0x3220(%r12), %rdi
movl %ebx, %esi
callq 0x2638a
movq %rax, %r14
testq %rax, %rax
jne 0x4015e
movq %r12, %rdi
movl %ebx, %esi
callq 0x40471
movq %rax, %r14
movl $0x800, %eax # imm = 0x800
movl %eax, 0x8(%r14)
movl 0x4(%r14), %ecx
orl 0xc(%r14), %ecx
orl %eax, %ecx
movl %ecx, 0x10(%r14)
movl %r13d, 0x4(%r14)
testq %rbp, %rbp
je 0x4017e
movups (%rbp), %xmm0
movups 0x9(%rbp), %xmm1
movups %xmm1, 0x19(%rsp)
movaps %xmm0, 0x10(%rsp)
movb 0x19(%rbp), %al
jmp 0x4018d
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%rsp)
movaps %xmm0, 0x10(%rsp)
movb $0x1, %al
movups 0x19(%rsp), %xmm0
movups %xmm0, 0x6d(%r14)
movaps 0x10(%rsp), %xmm0
movups %xmm0, 0x64(%r14)
movb %al, 0x7d(%r14)
movl 0x1c98(%r12), %eax
testb $0x1, %r13b
jne 0x401e4
cmpl %eax, 0xa8(%r14)
jne 0x401e4
testb $0x4, 0x11(%r14)
jne 0x40414
movl $0x400, %eax # imm = 0x400
orl 0x8(%r14), %eax
movl %eax, 0x8(%r14)
orl 0xc(%r14), %r13d
orl %eax, %r13d
movl %r13d, 0x10(%r14)
jmp 0x403c2
movl $0x400, %ecx # imm = 0x400
orl 0x8(%r14), %ecx
movl %r13d, %edx
orl 0xc(%r14), %edx
orl %ecx, %edx
movl %ecx, 0x8(%r14)
movl %edx, 0x10(%r14)
testb $0x1, %r13b
jne 0x4022a
callq 0x346a9
movq 0x8(%rsp), %rax
movsd (%rax), %xmm1
cvttps2dq %xmm1, %xmm3
movd %xmm3, %eax
cvtdq2ps %xmm3, %xmm1
movlps %xmm1, (%rsp)
testl %eax, %eax
jle 0x40236
movaps %xmm1, %xmm2
jmp 0x4024a
movl %eax, 0xa4(%r14)
jmp 0x403c2
movaps %xmm0, %xmm2
addss %xmm1, %xmm2
maxss 0x5d207(%rip), %xmm2 # 0x9d44c
movss %xmm2, (%rsp)
pshufd $0x55, %xmm3, %xmm3 # xmm3 = xmm3[1,1,1,1]
movd %xmm3, %eax
testl %eax, %eax
jle 0x4025d
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
jmp 0x40275
addps %xmm1, %xmm0
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
maxss 0x5d1e0(%rip), %xmm0 # 0x9d44c
movss %xmm0, 0x4(%rsp)
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm2
jbe 0x40433
ucomiss %xmm0, %xmm1
jbe 0x40433
movq 0x110(%r15), %rax
movq %rax, 0x48(%r14)
movq (%rsp), %rax
movq %rax, 0x58(%r14)
movq %rax, 0x50(%r14)
movq 0x9d230(%rip), %rax # 0xdd4d8
movl 0x1e18(%rax), %ecx
pushq $0x1
popq %rbp
movl %ecx, %edx
orl %ebp, %edx
movl %edx, 0x1e18(%rax)
movq 0x48(%r14), %rdx
movq %rdx, 0x1e2c(%rax)
andq $0x0, 0x1e34(%rax)
movl %ebp, 0x1e1c(%rax)
movb $0x1, 0x1e54(%rax)
orl $0x3, %ecx
movl %ecx, 0x1e18(%rax)
movq 0x50(%r14), %rcx
movq %rcx, 0x1e3c(%rax)
movl %ebp, 0x1e20(%rax)
movb $0x0, 0x1e54(%r12)
movq (%r15), %rcx
leaq 0x610a2(%rip), %rdx # 0xa13aa
leaq 0x10(%rsp), %r13
movl $0x100, %esi # imm = 0x100
movq %r13, %rdi
movl %ebx, %r8d
xorl %eax, %eax
callq 0x259dd
pushq $0x8
popq %rdi
xorps %xmm0, %xmm0
callq 0x27172
movq %r13, %rdi
xorl %esi, %esi
movl $0x210001bb, %edx # imm = 0x210001BB
callq 0x2e31a
movl %ebp, %edi
callq 0x272ae
movq 0x1d18(%r12), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x404ec
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x281b2
movl %eax, 0x90(%r12)
andq $0x0, 0x98(%r14)
xorl %eax, %eax
cmpq %rax, 0x18(%r14)
jne 0x40452
cmpq $0x0, 0x20(%r14)
jne 0x403a5
testb $0x8, 0x11(%r14)
jne 0x403a5
movl $0x800, %eax # imm = 0x800
orl 0x8(%r14), %eax
movl %eax, 0x8(%r14)
movl 0x4(%r14), %ecx
orl 0xc(%r14), %ecx
orl %eax, %ecx
movl %ecx, 0x10(%r14)
movq %r14, %rdi
callq 0x3db89
callq 0x33597
movq %rsp, %rdi
movss 0x5d027(%rip), %xmm0 # 0x9d3e4
callq 0x349e0
movl %ebx, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x60ec9(%rip), %rdi # 0xa12a6
leaq 0x5d9ad(%rip), %rsi # 0x9dd91
leaq 0x60ee7(%rip), %rcx # 0xa12d2
movl $0x3bef, %edx # imm = 0x3BEF
callq 0x24110
leaq 0x611d0(%rip), %rdi # 0xa15cc
leaq 0x5d98e(%rip), %rsi # 0x9dd91
leaq 0x60ec8(%rip), %rcx # 0xa12d2
movl $0x3bf0, %edx # imm = 0x3BF0
callq 0x24110
leaq 0x60f17(%rip), %rdi # 0xa1332
leaq 0x5d96f(%rip), %rsi # 0x9dd91
leaq 0x60ea9(%rip), %rcx # 0xa12d2
movl $0x3c01, %edx # imm = 0x3C01
callq 0x24110
leaq 0x60f51(%rip), %rdi # 0xa138b
leaq 0x5d950(%rip), %rsi # 0x9dd91
leaq 0x60e8a(%rip), %rcx # 0xa12d2
movl $0x3c14, %edx # imm = 0x3C14
callq 0x24110
leaq 0x60f63(%rip), %rdi # 0xa13bc
leaq 0x5d931(%rip), %rsi # 0x9dd91
leaq 0x60e6b(%rip), %rcx # 0xa12d2
movl $0x3c2f, %edx # imm = 0x3C2F
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::DockContextAddNode(ImGuiContext*, unsigned int) | static ImGuiDockNode* ImGui::DockContextAddNode(ImGuiContext* ctx, ImGuiID id)
{
// Generate an ID for the new node (the exact ID value doesn't matter as long as it is not already used) and add the first window.
if (id == 0)
id = DockContextGenNodeID(ctx);
else
IM_ASSERT(DockContextFindNodeByID(ctx, id) == NULL);
// We don't set node->LastFrameAlive on construction. Nodes are always created at all time to reflect .ini settings!
IMGUI_DEBUG_LOG_DOCKING("DockContextAddNode 0x%08X\n", id);
ImGuiDockNode* node = IM_NEW(ImGuiDockNode)(id);
ctx->DockContext.Nodes.SetVoidPtr(node->ID, node);
return node;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0x404ae
movl %esi, %ebp
leaq 0x3220(%rbx), %rdi
callq 0x2638a
testq %rax, %rax
je 0x404b8
leaq 0x65647(%rip), %rdi # 0xa5add
leaq 0x5d8f4(%rip), %rsi # 0x9dd91
leaq 0x65664(%rip), %rcx # 0xa5b08
movl $0x32b3, %edx # imm = 0x32B3
callq 0x24110
movq %rbx, %rdi
callq 0x3f331
movl %eax, %ebp
movl $0xc0, %edi
callq 0x2579a
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x3fd78
addq $0x3220, %rbx # imm = 0x3220
movl (%r14), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x26556
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::DockNodeTreeUpdateSplitter(ImGuiDockNode*) | const ImWchar* ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin) // find beginning-of-line
{
while (buf_mid_line > buf_begin && buf_mid_line[-1] != '\n')
buf_mid_line--;
return buf_mid_line;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x47b0e
movq %rdi, %r15
movq 0x28(%rdi), %rbx
testb $0x2, 0xbd(%r14)
je 0x47afd
testb $0x2, 0xbd(%rbx)
je 0x47af5
movslq 0x60(%r15), %r12
cmpq $-0x1, %r12
je 0x47f38
movq 0x95ae6(%rip), %rax # 0xdd4d8
movq %rax, 0x20(%rsp)
movq 0x48(%r14), %rax
leaq 0x90(%rsp), %rbp
movq %rax, -0x8(%rbp)
movq 0x48(%rbx), %rax
movq %rax, (%rbp)
leaq 0x50(%r14), %rdi
movq %rdi, 0x60(%rsp)
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
leaq 0x88(%rsp), %rdi
movq %r12, %rsi
callq 0x4b650
movss 0x10(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
leaq 0x50(%rbx), %rdi
movl %r12d, %eax
xorl $0x1, %eax
movslq %eax, %r13
movq %rdi, 0x68(%rsp)
movq %r13, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4b650
movss 0x10(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, (%rax)
movl 0x10(%rbx), %eax
orl 0x10(%r14), %eax
testb $0x20, %al
jne 0x47aa5
xorl %ecx, %ecx
testl %r12d, %r12d
setne %cl
shll $0x16, %ecx
addl $0x400000, %ecx # imm = 0x400000
testl %ecx, %eax
je 0x47b20
movq 0x20(%rsp), %r12
movq 0x1d18(%r12), %rax
movq 0x2a8(%rax), %r15
pushq $0x1b
popq %rdi
movss 0x55910(%rip), %xmm0 # 0x9d3d4
callq 0x26fc5
movss 0x1684(%r12), %xmm0
leaq 0x88(%rsp), %rsi
movq %r15, %rdi
movq %rbp, %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x4f9de
testb $0x2, 0xbd(%r14)
je 0x47afd
movq %r14, %rdi
callq 0x4799d
testb $0x2, 0xbd(%rbx)
je 0x47b0e
movq %rbx, %rdi
callq 0x4799d
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl (%r15), %edi
callq 0x37f8b
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq 0x20(%rsp), %r13
leaq 0x1658(%r13), %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x20(%r15), %rdi
addq $0x48, %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
addss 0x8(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
movq 0x28(%r15), %rdi
addq $0x48, %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x28(%r15), %rdi
addq $0x50, %rdi
movq %r12, %rsi
callq 0x4b650
movss 0x10(%rsp), %xmm0
addss (%rax), %xmm0
movss %xmm0, 0x10(%rsp)
leaq 0x5dd7c(%rip), %rdi # 0xa592f
callq 0x38094
movss 0x10(%rsp), %xmm0
subss 0x8(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
cmpl %eax, 0x1d6c(%r13)
jne 0x47cb2
pushq $0x1
popq %rdx
leaq 0x40(%rsp), %rcx
movq %r14, %rdi
movl %r12d, %esi
callq 0x48257
leaq 0x50(%rsp), %rcx
xorl %r13d, %r13d
movq %rbx, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x48257
leaq 0x30(%rsp), %rbp
cmpl 0x40(%rsp), %r13d
jge 0x47c60
leaq 0x40(%rsp), %rdi
movl %r13d, %esi
callq 0x4ab50
movq (%rax), %rdi
callq 0x4baba
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x30(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
addss 0x8(%rsp), %xmm0
movaps %xmm0, %xmm1
movaps 0x70(%rsp), %xmm3
cmpless %xmm3, %xmm1
movaps %xmm1, %xmm2
andnps %xmm0, %xmm2
andps %xmm3, %xmm1
orps %xmm2, %xmm1
incl %r13d
movaps %xmm1, 0x70(%rsp)
jmp 0x47c04
xorl %ebp, %ebp
leaq 0x38(%rsp), %r13
cmpl 0x50(%rsp), %ebp
jge 0x47cb2
leaq 0x50(%rsp), %rdi
movl %ebp, %esi
callq 0x4ab50
movq (%rax), %rdi
callq 0x4baba
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x30(%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
subss 0x8(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
minss %xmm0, %xmm1
movss %xmm1, 0x10(%rsp)
incl %ebp
jmp 0x47c67
leaq 0x48(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rbx), %r13
movq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x30(%rsp)
movq 0x68(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x20(%rsp)
movq %r13, 0x80(%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
movss %xmm0, 0x2c(%rsp)
leaq 0x5dbef(%rip), %rdi # 0xa592f
callq 0x38094
movss 0x8(%rsp), %xmm1
addss 0x2c(%rsp), %xmm1
subss 0x10(%rsp), %xmm1
movaps 0x70(%rsp), %xmm0
subss 0x20(%rsp), %xmm0
leaq 0x88(%rsp), %rdi
leaq 0x30(%rsp), %rcx
leaq 0x1c(%rsp), %r8
movss 0x556d0(%rip), %xmm2 # 0x9d44c
movss 0x556cc(%rip), %xmm3 # 0x9d450
movl %eax, %esi
movl %r12d, %edx
callq 0x6807d
testb %al, %al
movq %rbx, 0x10(%rsp)
je 0x47f0f
cmpl $0x0, 0x40(%rsp)
jle 0x47f0f
cmpl $0x0, 0x50(%rsp)
jle 0x47f0f
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x58(%r14), %rdi
movq %r12, %rsi
callq 0x4b650
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
movq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x4b650
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x68(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x4b650
movss 0x8(%rsp), %xmm0
subss (%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x80(%rsp), %rdi
movq %r12, %rsi
callq 0x4b650
movss (%rax), %xmm0
subss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x58(%rbx), %rdi
movq %r12, %rsi
callq 0x4b650
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x4b650
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rax)
xorl %ebx, %ebx
cmpq $0x2, %rbx
je 0x47ec3
movq %rbx, %rax
shlq $0x4, %rax
leaq (%rsp,%rax), %r13
addq $0x40, %r13
xorl %ebp, %ebp
cmpl (%r13), %ebp
jge 0x47ebe
movq %r13, %rdi
movl %ebp, %esi
callq 0x4ab50
movq (%rax), %rax
movq 0x18(%rax), %rcx
cmpq %r15, %rcx
je 0x47eba
addq $0x18, %rax
cmpl %r12d, 0x60(%rcx)
jne 0x47e94
movq 0x20(%rcx,%rbx,8), %rcx
orw $0x8000, 0xbc(%rcx) # imm = 0x8000
jmp 0x47e94
incl %ebp
jmp 0x47e84
incq %rbx
jmp 0x47e6d
movsd 0x48(%r14), %xmm0
movsd 0x50(%r14), %xmm1
movq %r14, %rdi
xorl %esi, %esi
callq 0x46f8f
movq 0x10(%rsp), %rdi
movsd 0x48(%rdi), %xmm0
movsd 0x50(%rdi), %xmm1
xorl %esi, %esi
callq 0x46f8f
movq 0x955e2(%rip), %rax # 0xdd4d8
xorps %xmm0, %xmm0
ucomiss 0x325c(%rax), %xmm0
jb 0x47f0f
movss 0x1c(%rax), %xmm0
movss %xmm0, 0x325c(%rax)
callq 0x38051
pushq $0x10
popq %rbx
leaq (%rsp,%rbx), %rdi
addq $0x40, %rdi
callq 0x4aba2
addq $-0x10, %rbx
cmpq $-0x10, %rbx
jne 0x47f17
movq 0x10(%rsp), %rbx
jmp 0x47aeb
leaq 0x5d9a1(%rip), %rdi # 0xa58e0
leaq 0x55e4b(%rip), %rsi # 0x9dd91
leaq 0x5d9aa(%rip), %rcx # 0xa58f7
movl $0x3b29, %edx # imm = 0x3B29
callq 0x24110
jmp 0x47f5d
jmp 0x47f5d
jmp 0x47f5d
movq %rax, %rbx
pushq $0x10
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x40, %rdi
callq 0x4aba2
addq $-0x10, %r14
cmpq $-0x10, %r14
jne 0x47f64
movq %rbx, %rdi
callq 0x243e0
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
DockNodeFindInfo(ImGuiDockNode*, ImGuiDockNodeTreeInfo*) | static void DockNodeFindInfo(ImGuiDockNode* node, ImGuiDockNodeTreeInfo* info)
{
if (node->Windows.Size > 0)
{
if (info->FirstNodeWithWindows == NULL)
info->FirstNodeWithWindows = node;
info->CountNodesWithWindows++;
}
if (node->IsCentralNode())
{
IM_ASSERT(info->CentralNode == NULL); // Should be only one
IM_ASSERT(node->IsLeafNode() && "If you get this assert: please submit .ini file + repro of actions leading to this.");
info->CentralNode = node;
}
if (info->CountNodesWithWindows > 1 && info->CentralNode != NULL)
return;
if (node->ChildNodes[0])
DockNodeFindInfo(node->ChildNodes[0], info);
if (node->ChildNodes[1])
DockNodeFindInfo(node->ChildNodes[1], info);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x0, 0x30(%r14)
jle 0x481d4
cmpq $0x0, 0x8(%rbx)
jne 0x481d1
movq %r14, 0x8(%rbx)
incl 0x10(%rbx)
testb $0x8, 0x11(%r14)
je 0x481eb
cmpq $0x0, (%rbx)
jne 0x48219
cmpq $0x0, 0x20(%r14)
jne 0x48238
movq %r14, (%rbx)
cmpl $0x2, 0x10(%rbx)
jl 0x481f7
cmpq $0x0, (%rbx)
jne 0x48211
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x48208
movq %rbx, %rsi
callq 0x481b5
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x481bf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5d591(%rip), %rdi # 0xa57b1
leaq 0x55b6a(%rip), %rsi # 0x9dd91
leaq 0x5d59f(%rip), %rcx # 0xa57cd
movl $0x35a7, %edx # imm = 0x35A7
callq 0x24110
leaq 0x5d5ce(%rip), %rdi # 0xa580d
leaq 0x55b4b(%rip), %rsi # 0x9dd91
leaq 0x5d580(%rip), %rcx # 0xa57cd
movl $0x35a8, %edx # imm = 0x35A8
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
DockNodeTreeUpdateSplitterFindTouchingNode(ImGuiDockNode*, ImGuiAxis, int, ImVector<ImGuiDockNode*>*) | static void DockNodeTreeUpdateSplitterFindTouchingNode(ImGuiDockNode* node, ImGuiAxis axis, int side, ImVector<ImGuiDockNode*>* touching_nodes)
{
if (node->IsLeafNode())
{
touching_nodes->push_back(node);
return;
}
if (node->ChildNodes[0]->IsVisible)
if (node->SplitAxis != axis || side == 0 || !node->ChildNodes[1]->IsVisible)
DockNodeTreeUpdateSplitterFindTouchingNode(node->ChildNodes[0], axis, side, touching_nodes);
if (node->ChildNodes[1]->IsVisible)
if (node->SplitAxis != axis || side == 1 || !node->ChildNodes[0]->IsVisible)
DockNodeTreeUpdateSplitterFindTouchingNode(node->ChildNodes[1], axis, side, touching_nodes);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x482c6
testb $0x2, 0xbd(%rdi)
je 0x4829f
testl %ebp, %ebp
je 0x48292
cmpl %r14d, 0x60(%r15)
jne 0x48292
movq 0x28(%r15), %rax
testb $0x2, 0xbd(%rax)
jne 0x4829f
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x48257
movq 0x28(%r15), %rdi
testb $0x2, 0xbd(%rdi)
je 0x482d4
cmpl $0x1, %ebp
je 0x48266
cmpl %r14d, 0x60(%r15)
jne 0x48266
movq 0x20(%r15), %rax
testb $0x2, 0xbd(%rax)
je 0x48266
jmp 0x482d4
movq %rsp, %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x4ab02
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImGui::DockNodeCalcTabBarLayout(ImGuiDockNode const*, ImRect*, ImRect*, ImVec2*, ImVec2*) | static void ImGui::DockNodeCalcTabBarLayout(const ImGuiDockNode* node, ImRect* out_title_rect, ImRect* out_tab_bar_rect, ImVec2* out_window_menu_button_pos, ImVec2* out_close_button_pos)
{
ImGuiContext& g = *GImGui;
ImGuiStyle& style = g.Style;
ImRect r = ImRect(node->Pos.x, node->Pos.y, node->Pos.x + node->Size.x, node->Pos.y + g.FontSize + g.Style.FramePadding.y * 2.0f);
if (out_title_rect) { *out_title_rect = r; }
r.Min.x += style.WindowBorderSize;
r.Max.x -= style.WindowBorderSize;
float button_sz = g.FontSize;
ImVec2 window_menu_button_pos = r.Min;
r.Min.x += style.FramePadding.x;
r.Max.x -= style.FramePadding.x;
if (node->HasCloseButton)
{
r.Max.x -= button_sz;
if (out_close_button_pos) *out_close_button_pos = ImVec2(r.Max.x - style.FramePadding.x, r.Min.y);
}
if (node->HasWindowMenuButton && style.WindowMenuButtonPosition == ImGuiDir_Left)
{
r.Min.x += button_sz + style.ItemInnerSpacing.x;
}
else if (node->HasWindowMenuButton && style.WindowMenuButtonPosition == ImGuiDir_Right)
{
r.Max.x -= button_sz + style.FramePadding.x;
window_menu_button_pos = ImVec2(r.Max.x, r.Min.y);
}
if (out_tab_bar_rect) { *out_tab_bar_rect = r; }
if (out_window_menu_button_pos) { *out_window_menu_button_pos = window_menu_button_pos; }
} | movq 0x951f2(%rip), %rax # 0xdd4d8
movsd 0x48(%rdi), %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0 # xmm0 = xmm0[1,1],xmm1[1,1]
movss 0x50(%rdi), %xmm2
addss %xmm1, %xmm2
movss 0x1a88(%rax), %xmm5
movaps %xmm0, %xmm4
addss %xmm5, %xmm4
movss 0x1680(%rax), %xmm3
addss %xmm3, %xmm3
addss %xmm4, %xmm3
testq %rsi, %rsi
je 0x48334
movlps %xmm1, (%rsi)
movss %xmm2, 0x8(%rsi)
movss %xmm3, 0xc(%rsi)
movss 0x1a88(%rax), %xmm5
movss 0x1654(%rax), %xmm6
movss 0x167c(%rax), %xmm4
addss %xmm6, %xmm1
subss %xmm6, %xmm2
subss %xmm4, %xmm2
movl 0xbc(%rdi), %esi
btl $0xb, %esi
jae 0x4837e
subss %xmm5, %xmm2
testq %r8, %r8
je 0x4837e
movaps %xmm2, %xmm6
subss %xmm4, %xmm6
movss %xmm6, (%r8)
movss %xmm0, 0x4(%r8)
movzwl 0xbc(%rdi), %esi
addss %xmm1, %xmm4
btl $0xc, %esi
jae 0x483b4
movl 0x1668(%rax), %esi
cmpl $0x1, %esi
je 0x483a5
testl %esi, %esi
jne 0x483b4
addss 0x1694(%rax), %xmm5
addss %xmm5, %xmm4
jmp 0x483b4
addss 0x167c(%rax), %xmm5
subss %xmm5, %xmm2
movaps %xmm2, %xmm1
testq %rdx, %rdx
je 0x483cc
movss %xmm4, (%rdx)
movss %xmm0, 0x4(%rdx)
movss %xmm2, 0x8(%rdx)
movss %xmm3, 0xc(%rdx)
testq %rcx, %rcx
je 0x483e5
movd %xmm0, %eax
movd %xmm1, %edx
shlq $0x20, %rax
movl %edx, %edx
orq %rax, %rdx
movq %rdx, (%rcx)
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
DockNodeIsDropAllowedOne(ImGuiWindow*, ImGuiWindow*) | static bool DockNodeIsDropAllowedOne(ImGuiWindow* payload, ImGuiWindow* host_window)
{
if (host_window->DockNodeAsHost && host_window->DockNodeAsHost->IsDockSpace() && payload->BeginOrderWithinContext < host_window->BeginOrderWithinContext)
return false;
ImGuiWindowClass* host_class = host_window->DockNodeAsHost ? &host_window->DockNodeAsHost->WindowClass : &host_window->WindowClass;
ImGuiWindowClass* payload_class = &payload->WindowClass;
if (host_class->ClassId != payload_class->ClassId)
{
if (host_class->ClassId != 0 && host_class->DockingAllowUnclassed && payload_class->ClassId == 0)
return true;
if (payload_class->ClassId != 0 && payload_class->DockingAllowUnclassed && host_class->ClassId == 0)
return true;
return false;
}
return true;
} | movq 0x408(%rsi), %rax
testq %rax, %rax
je 0x48445
testb $0x4, 0x11(%rax)
je 0x48445
movzwl 0xd6(%rdi), %ecx
cmpw 0xd6(%rsi), %cx
jl 0x4847c
leaq 0x64(%rax), %rcx
addq $0x14, %rsi
testq %rax, %rax
cmovneq %rcx, %rsi
movl (%rsi), %ecx
movl 0x14(%rdi), %edx
movb $0x1, %al
cmpl %edx, %ecx
je 0x4846d
testl %ecx, %ecx
je 0x4846e
testl %edx, %edx
jne 0x4846e
cmpb $0x0, 0x19(%rsi)
je 0x4846e
retq
testl %edx, %edx
je 0x4847c
testl %ecx, %ecx
jne 0x4847c
cmpb $0x0, 0x2d(%rdi)
jne 0x4846d
xorl %eax, %eax
retq
| /binji[P]binjgb/third_party/imgui/imgui.cpp |
ImVector<ImGuiStorage::ImGuiStoragePair>::insert(ImGuiStorage::ImGuiStoragePair const*, ImGuiStorage::ImGuiStoragePair const&) | inline T* insert(const T* it, const T& v) { IM_ASSERT(it >= Data && it <= Data + Size); const ptrdiff_t off = it - Data; if (Size == Capacity) reserve(_grow_capacity(Size + 1)); if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(T)); memcpy(&Data[off], &v, sizeof(v)); Size++; return Data + off; } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
ja 0x48712
movq %rdi, %r14
movslq (%rdi), %rcx
movq %rcx, %rax
shlq $0x4, %rax
addq %rsi, %rax
cmpq %rbx, %rax
jb 0x48712
movq %rdx, %r15
subq %rsi, %rbx
movq %rbx, %r12
sarq $0x4, %r12
cmpl 0x4(%r14), %ecx
jne 0x486d4
leal 0x1(%rcx), %esi
testl %ecx, %ecx
je 0x486bd
pushq $0x2
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
addl %ecx, %eax
jmp 0x486c0
pushq $0x8
popq %rax
cmpl %esi, %eax
cmovgl %eax, %esi
movq %r14, %rdi
callq 0x4bc78
movslq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %r12, %rcx
jle 0x486f4
leaq (%rsi,%rbx), %rdi
addq $0x10, %rdi
addq %rbx, %rsi
shlq $0x4, %rcx
movq %rcx, %rdx
callq 0x24100
movq 0x8(%r14), %rsi
movups (%r15), %xmm0
movups %xmm0, (%rsi,%rbx)
incl (%r14)
addq 0x8(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5b1df(%rip), %rdi # 0xa38f8
leaq 0x5aee3(%rip), %rsi # 0xa3603
leaq 0x5ddb0(%rip), %rcx # 0xa64d7
movl $0x720, %edx # imm = 0x720
callq 0x24110
nop
| /binji[P]binjgb/third_party/imgui/imgui.h |
ImGuiWindowTempData::~ImGuiWindowTempData() | struct IMGUI_API ImGuiWindowTempData
{
// Layout
ImVec2 CursorPos; // Current emitting position, in absolute coordinates.
ImVec2 CursorPosPrevLine;
ImVec2 CursorStartPos; // Initial position after Begin(), generally ~ window position + WindowPadding.
ImVec2 CursorMaxPos; // Used to implicitly calculate ContentSize at the beginning of next frame, for scrolling range and auto-resize. Always growing during the frame.
ImVec2 IdealMaxPos; // Used to implicitly calculate ContentSizeIdeal at the beginning of next frame, for auto-resize only. Always growing during the frame.
ImVec2 CurrLineSize;
ImVec2 PrevLineSize;
float CurrLineTextBaseOffset; // Baseline offset (0.0f by default on a new line, generally == style.FramePadding.y when a framed item has been added).
float PrevLineTextBaseOffset;
ImVec1 Indent; // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
ImVec1 ColumnsOffset; // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API.
ImVec1 GroupOffset;
// Keyboard/Gamepad navigation
ImGuiNavLayer NavLayerCurrent; // Current layer, 0..31 (we currently only use 0..1)
short NavLayersActiveMask; // Which layers have been written to (result from previous frame)
short NavLayersActiveMaskNext;// Which layers have been written to (accumulator for current frame)
ImGuiID NavFocusScopeIdCurrent; // Current focus scope ID while appending
bool NavHideHighlightOneFrame;
bool NavHasScroll; // Set when scrolling can be used (ScrollMax > 0.0f)
// Miscellaneous
bool MenuBarAppending; // FIXME: Remove this
ImVec2 MenuBarOffset; // MenuBarOffset.x is sort of equivalent of a per-layer CursorPos.x, saved/restored as we switch to the menu bar. The only situation when MenuBarOffset.y is > 0 if when (SafeAreaPadding.y > FramePadding.y), often used on TVs.
ImGuiMenuColumns MenuColumns; // Simplified columns storage for menu items measurement
int TreeDepth; // Current tree depth.
ImU32 TreeJumpToParentOnPopMask; // Store a copy of !g.NavIdIsAlive for TreeDepth 0..31.. Could be turned into a ImU64 if necessary.
ImVector<ImGuiWindow*> ChildWindows;
ImGuiStorage* StateStorage; // Current persistent per-window storage (store e.g. tree node open/close state)
ImGuiOldColumns* CurrentColumns; // Current columns set
int CurrentTableIdx; // Current table index (into g.Tables)
ImGuiLayoutType LayoutType;
ImGuiLayoutType ParentLayoutType; // Layout type of parent window at the time of Begin()
int FocusCounterTabStop; // (Legacy Focus/Tabbing system) Same, but only count widgets which you can Tab through.
// Local parameters stacks
// We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings.
float ItemWidth; // Current item width (>0.0: width in pixels, <0.0: align xx pixels to the right of window).
float TextWrapPos; // Current text wrap pos.
ImVector<float> ItemWidthStack; // Store item widths to restore (attention: .back() is not == ItemWidth)
ImVector<float> TextWrapPosStack; // Store text wrap pos to restore (attention: .back() is not == TextWrapPos)
} | pushq %rbx
movq %rdi, %rbx
addq $0xd0, %rdi
callq 0x4afea
leaq 0xc0(%rbx), %rdi
callq 0x4afea
addq $0x88, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x4aad0
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImGuiContext::ImGuiContext(ImFontAtlas*) | ImGuiContext(ImFontAtlas* shared_font_atlas)
{
Initialized = false;
ConfigFlagsCurrFrame = ConfigFlagsLastFrame = ImGuiConfigFlags_None;
FontAtlasOwnedByContext = shared_font_atlas ? false : true;
Font = NULL;
FontSize = FontBaseSize = 0.0f;
IO.Fonts = shared_font_atlas ? shared_font_atlas : IM_NEW(ImFontAtlas)();
Time = 0.0f;
FrameCount = 0;
FrameCountEnded = FrameCountPlatformEnded = FrameCountRendered = -1;
WithinFrameScope = WithinFrameScopeWithImplicitWindow = WithinEndChild = false;
GcCompactAll = false;
TestEngineHookItems = false;
TestEngine = NULL;
WindowsActiveCount = 0;
CurrentWindow = NULL;
HoveredWindow = NULL;
HoveredWindowUnderMovingWindow = NULL;
HoveredDockNode = NULL;
MovingWindow = NULL;
WheelingWindow = NULL;
WheelingWindowTimer = 0.0f;
DebugHookIdInfo = 0;
HoveredId = HoveredIdPreviousFrame = 0;
HoveredIdAllowOverlap = false;
HoveredIdUsingMouseWheel = HoveredIdPreviousFrameUsingMouseWheel = false;
HoveredIdDisabled = false;
HoveredIdTimer = HoveredIdNotActiveTimer = 0.0f;
ActiveId = 0;
ActiveIdIsAlive = 0;
ActiveIdTimer = 0.0f;
ActiveIdIsJustActivated = false;
ActiveIdAllowOverlap = false;
ActiveIdNoClearOnFocusLoss = false;
ActiveIdHasBeenPressedBefore = false;
ActiveIdHasBeenEditedBefore = false;
ActiveIdHasBeenEditedThisFrame = false;
ActiveIdUsingMouseWheel = false;
ActiveIdUsingNavDirMask = 0x00;
ActiveIdUsingNavInputMask = 0x00;
ActiveIdUsingKeyInputMask = 0x00;
ActiveIdClickOffset = ImVec2(-1, -1);
ActiveIdWindow = NULL;
ActiveIdSource = ImGuiInputSource_None;
ActiveIdMouseButton = -1;
ActiveIdPreviousFrame = 0;
ActiveIdPreviousFrameIsAlive = false;
ActiveIdPreviousFrameHasBeenEditedBefore = false;
ActiveIdPreviousFrameWindow = NULL;
LastActiveId = 0;
LastActiveIdTimer = 0.0f;
CurrentItemFlags = ImGuiItemFlags_None;
CurrentDpiScale = 0.0f;
CurrentViewport = NULL;
MouseViewport = MouseLastHoveredViewport = NULL;
PlatformLastFocusedViewportId = 0;
ViewportFrontMostStampCount = 0;
NavWindow = NULL;
NavId = NavFocusScopeId = NavActivateId = NavActivateDownId = NavActivatePressedId = NavActivateInputId = 0;
NavJustTabbedId = NavJustMovedToId = NavJustMovedToFocusScopeId = NavNextActivateId = 0;
NavActivateFlags = NavNextActivateFlags = ImGuiActivateFlags_None;
NavJustMovedToKeyMods = ImGuiKeyModFlags_None;
NavInputSource = ImGuiInputSource_None;
NavLayer = ImGuiNavLayer_Main;
NavIdTabCounter = INT_MAX;
NavIdIsAlive = false;
NavMousePosDirty = false;
NavDisableHighlight = true;
NavDisableMouseHover = false;
NavAnyRequest = false;
NavInitRequest = false;
NavInitRequestFromMove = false;
NavInitResultId = 0;
NavMoveSubmitted = false;
NavMoveScoringItems = false;
NavMoveForwardToNextFrame = false;
NavMoveFlags = ImGuiNavMoveFlags_None;
NavMoveScrollFlags = ImGuiScrollFlags_None;
NavMoveKeyMods = ImGuiKeyModFlags_None;
NavMoveDir = NavMoveDirForDebug = NavMoveClipDir = ImGuiDir_None;
NavScoringDebugCount = 0;
NavTabbingInputableRemaining = 0;
NavWindowingTarget = NavWindowingTargetAnim = NavWindowingListWindow = NULL;
NavWindowingTimer = NavWindowingHighlightAlpha = 0.0f;
NavWindowingToggleLayer = false;
TabFocusRequestCurrWindow = TabFocusRequestNextWindow = NULL;
TabFocusRequestCurrCounterTabStop = INT_MAX;
TabFocusRequestNextCounterTabStop = INT_MAX;
TabFocusPressed = false;
DimBgRatio = 0.0f;
MouseCursor = ImGuiMouseCursor_Arrow;
DragDropActive = DragDropWithinSource = DragDropWithinTarget = false;
DragDropSourceFlags = ImGuiDragDropFlags_None;
DragDropSourceFrameCount = -1;
DragDropMouseButton = -1;
DragDropTargetId = 0;
DragDropAcceptFlags = ImGuiDragDropFlags_None;
DragDropAcceptIdCurrRectSurface = 0.0f;
DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0;
DragDropAcceptFrameCount = -1;
DragDropHoldJustPressedId = 0;
memset(DragDropPayloadBufLocal, 0, sizeof(DragDropPayloadBufLocal));
CurrentTable = NULL;
TablesTempDataStacked = 0;
CurrentTabBar = NULL;
TempInputId = 0;
ColorEditOptions = ImGuiColorEditFlags_DefaultOptions_;
ColorEditLastHue = ColorEditLastSat = 0.0f;
ColorEditLastColor = 0;
SliderCurrentAccum = 0.0f;
SliderCurrentAccumDirty = false;
DragCurrentAccumDirty = false;
DragCurrentAccum = 0.0f;
DragSpeedDefaultRatio = 1.0f / 100.0f;
DisabledAlphaBackup = 0.0f;
DisabledStackSize = 0;
ScrollbarClickDeltaToGrabCenter = 0.0f;
TooltipOverrideCount = 0;
TooltipSlowDelay = 0.50f;
PlatformImePos = PlatformImeLastPos = ImVec2(FLT_MAX, FLT_MAX);
PlatformImePosViewport = 0;
PlatformLocaleDecimalPoint = '.';
SettingsLoaded = false;
SettingsDirtyTimer = 0.0f;
HookIdNext = 0;
LogEnabled = false;
LogType = ImGuiLogType_None;
LogNextPrefix = LogNextSuffix = NULL;
LogFile = NULL;
LogLinePosY = FLT_MAX;
LogLineFirstItem = false;
LogDepthRef = 0;
LogDepthToExpand = LogDepthToExpandDefault = 2;
DebugItemPickerActive = false;
DebugItemPickerBreakId = 0;
memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
FramerateSecPerFrameIdx = FramerateSecPerFrameCount = 0;
FramerateSecPerFrameAccum = 0.0f;
WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
memset(TempBuffer, 0, sizeof(TempBuffer));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x24aa4
leaq 0x1560(%rbx), %r14
movl $0xe0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x241f0
leaq 0x1640(%rbx), %rdi
callq 0x2482c
leaq 0x1a90(%rbx), %rdi
callq 0x4d2ac
andq $0x0, 0x1d0c(%rbx)
andq $0x0, 0x1d48(%rbx)
andq $0x0, 0x1d90(%rbx)
leaq 0x1e18(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x1f5c(%rbx)
movups %xmm0, 0x1f6c(%rbx)
movups %xmm0, 0x1cb8(%rbx)
movups %xmm0, 0x1cc8(%rbx)
movups %xmm0, 0x1cd8(%rbx)
movups %xmm0, 0x1ce8(%rbx)
movups %xmm0, 0x1cf8(%rbx)
movups %xmm0, 0x1dc4(%rbx)
movups %xmm0, 0x1dd4(%rbx)
movups %xmm0, 0x1de4(%rbx)
movups %xmm0, 0x1df4(%rbx)
movups %xmm0, 0x1e04(%rbx)
movl $0x120, %edx # imm = 0x120
xorl %esi, %esi
callq 0x241f0
movl $0x3f800000, 0x1f7c(%rbx) # imm = 0x3F800000
xorps %xmm1, %xmm1
movups %xmm1, 0x1fdc(%rbx)
movups %xmm1, 0x2008(%rbx)
movups %xmm1, 0x2020(%rbx)
andl $0x0, 0x2040(%rbx)
movups %xmm1, 0x2030(%rbx)
movl $0x7f7fffff, %eax # imm = 0x7F7FFFFF
movl %eax, 0x204c(%rbx)
movsd 0x54253(%rip), %xmm0 # 0x9d1a0
movsd %xmm0, 0x2044(%rbx)
andl $0x0, 0x2070(%rbx)
movups %xmm1, 0x2050(%rbx)
movups %xmm1, 0x2060(%rbx)
movl %eax, 0x207c(%rbx)
movsd %xmm0, 0x2074(%rbx)
movups %xmm1, 0x2080(%rbx)
andl $0x0, 0x20a0(%rbx)
movups %xmm1, 0x2090(%rbx)
movl %eax, 0x20ac(%rbx)
movsd %xmm0, 0x20a4(%rbx)
movups %xmm1, 0x2138(%rbx)
movups %xmm1, 0x2128(%rbx)
andw $0x0, 0x2148(%rbx)
movups %xmm1, 0x2110(%rbx)
movabsq $-0x100000000, %rbp # imm = 0xFFFFFFFF00000000
movq %rbp, 0x2120(%rbx)
movb $0x0, 0x214a(%rbx)
movups %xmm1, 0x2150(%rbx)
movups %xmm1, 0x2180(%rbx)
leaq 0x2210(%rbx), %r12
leaq 0x30f8(%rbx), %r13
movups %xmm1, 0x21b0(%rbx)
movups %xmm1, 0x21c0(%rbx)
movups %xmm1, 0x21d0(%rbx)
movups %xmm1, 0x21e0(%rbx)
movups %xmm1, 0x21f0(%rbx)
andq $0x0, 0x2200(%rbx)
movl $0xee8, %edx # imm = 0xEE8
movq %r12, %rdi
xorl %esi, %esi
callq 0x241f0
movq %r13, %rdi
callq 0x563ba
xorps %xmm0, %xmm0
movups %xmm0, 0x3240(%rbx)
movups %xmm0, 0x3230(%rbx)
movups %xmm0, 0x3220(%rbx)
andq $0x0, 0x3250(%rbx)
movups %xmm0, 0x32c8(%rbx)
andl $0x0, 0x3304(%rbx)
movups %xmm0, 0x317c(%rbx)
movups %xmm0, 0x318c(%rbx)
movups %xmm0, 0x319c(%rbx)
movups %xmm0, 0x31ac(%rbx)
movups %xmm0, 0x31e0(%rbx)
movups %xmm0, 0x31f0(%rbx)
movups %xmm0, 0x3200(%rbx)
movups %xmm0, 0x3260(%rbx)
movups %xmm0, 0x3270(%rbx)
movups %xmm0, 0x3280(%rbx)
movups %xmm0, 0x3290(%rbx)
movups %xmm0, 0x32a0(%rbx)
movw $0x101, 0x3308(%rbx) # imm = 0x101
xorl %eax, %eax
movb %al, 0x330a(%rbx)
orq $-0x1, 0x330c(%rbx)
movups %xmm0, 0x3318(%rbx)
movups %xmm0, 0x3328(%rbx)
movb %al, (%rbx)
andq $0x0, 0x1a78(%rbx)
testq %r15, %r15
sete 0x1(%rbx)
movups %xmm0, 0x1a80(%rbx)
jne 0x49106
movl $0x490, %edi # imm = 0x490
callq 0x2579a
movq %rax, %r15
movq %rax, %rdi
callq 0x51286
movq %r15, 0xa8(%rbx)
andq $0x0, 0x1c90(%rbx)
movaps 0x54094(%rip), %xmm0 # 0x9d1b0
movups %xmm0, 0x1c98(%rbx)
andq $0x0, 0x1cb0(%rbx)
andl $0x0, 0x1d08(%rbx)
xorl %eax, %eax
movb %al, 0x1cac(%rbx)
andl $0x0, 0x1ca8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x1d18(%rbx)
movups %xmm0, 0x1d28(%rbx)
movups %xmm0, 0x1d38(%rbx)
movups %xmm0, 0x1d50(%rbx)
movups %xmm0, 0x1d60(%rbx)
movups %xmm0, 0x1d6f(%rbx)
movups %xmm0, 0x1d80(%rbx)
movabsq $-0x407fffff40800000, %rcx # imm = 0xBF800000BF800000
movq %rcx, 0x1d90(%rbx)
andq $0x0, 0x1d98(%rbx)
movq %rbp, 0x1da0(%rbx)
andl $0x0, 0x1da8(%rbx)
andw $0x0, 0x1dac(%rbx)
andl $0x0, 0x1f38(%rbx)
andl $0x0, 0x1f80(%rbx)
andl $0x0, 0x1dc0(%rbx)
movups %xmm0, 0x1db0(%rbx)
movups %xmm0, 0x1f40(%rbx)
movups %xmm0, 0x1f4c(%rbx)
movups %xmm0, 0x1f88(%rbx)
movups %xmm0, 0x1f98(%rbx)
movups %xmm0, 0x1fa8(%rbx)
movups %xmm0, 0x1fb8(%rbx)
movabsq $0x7fffffff00000000, %rcx # imm = 0x7FFFFFFF00000000
movq %rcx, 0x1fc8(%rbx)
andw $0x0, 0x1fd0(%rbx)
movb $0x1, 0x1fd2(%rbx)
andl $0x0, 0x1fd8(%rbx)
andw $0x0, 0x1fec(%rbx)
movb %al, 0x1fee(%rbx)
andl $0x0, 0x1fd3(%rbx)
orq $-0x1, 0x2000(%rbx)
movaps 0x53f8b(%rip), %xmm1 # 0x9d1c0
movups %xmm1, 0x1ff0(%rbx)
andq $0x0, 0x2018(%rbx)
movb %al, 0x20d0(%rbx)
movups %xmm0, 0x20c0(%rbx)
movups %xmm0, 0x20b0(%rbx)
movups %xmm0, 0x20d8(%rbx)
movabsq $0x7fffffff7fffffff, %rcx # imm = 0x7FFFFFFF7FFFFFFF
movq %rcx, 0x20e8(%rbx)
movb %al, 0x20f0(%rbx)
andl $0x0, 0x2100(%rbx)
andl $0x0, 0x20fb(%rbx)
andq $0x0, 0x20f4(%rbx)
orq $-0x1, 0x2104(%rbx)
movups %xmm0, 0x2160(%rbx)
andl $0x0, 0x2170(%rbx)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movq %rcx, 0x2174(%rbx)
andq $0x0, 0x2208(%rbx)
movabsq $0xa90000000000000, %rcx # imm = 0xA90000000000000
movq %rcx, 0x3168(%rbx)
movups %xmm0, 0x2190(%rbx)
movups %xmm0, 0x219c(%rbx)
andq $0x0, 0x3170(%rbx)
andl $0x0, 0x3178(%rbx)
andl $0x0, 0x31bc(%rbx)
andw $0x0, 0x31c0(%rbx)
movsd 0x53ed5(%rip), %xmm1 # 0x9d1d0
movsd %xmm1, 0x31c4(%rbx)
andl $0x0, 0x31d4(%rbx)
andq $0x0, 0x31cc(%rbx)
movl $0x3f000000, 0x31d8(%rbx) # imm = 0x3F000000
movaps 0x53ebd(%rip), %xmm1 # 0x9d1e0
movups %xmm1, 0x3200(%rbx)
andq $0x0, 0x3210(%rbx)
movb $0x2e, 0x3218(%rbx)
movb %al, 0x3258(%rbx)
andl $0x0, 0x325c(%rbx)
andl $0x0, 0x32b0(%rbx)
movb %al, 0x32b4(%rbx)
andl $0x0, 0x32b8(%rbx)
andq $0x0, 0x32c0(%rbx)
movups %xmm0, 0x32d8(%rbx)
movl $0x7f7fffff, 0x32e8(%rbx) # imm = 0x7F7FFFFF
movb %al, 0x32ec(%rbx)
andl $0x0, 0x32f0(%rbx)
pushq $0x2
popq %rcx
movl %ecx, 0x32f8(%rbx)
movl %ecx, 0x32f4(%rbx)
movb %al, 0x32fc(%rbx)
andl $0x0, 0x3300(%rbx)
leaq 0x3338(%rbx), %rdi
movl $0x1ec, %edx # imm = 0x1EC
xorl %esi, %esi
callq 0x241f0
orl $-0x1, 0x352c(%rbx)
orq $-0x1, 0x3524(%rbx)
addq $0x3530, %rbx # imm = 0x3530
movl $0xc01, %edx # imm = 0xC01
movq %rbx, %rdi
xorl %esi, %esi
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x241f0
jmp 0x493e7
movq %rax, (%rsp)
leaq 0x31e0(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq 0x31f0(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x3220(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x3260(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x3270(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x3280(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x3290(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x32a0(%rbx), %rbp
leaq 0x32c8(%rbx), %r15
leaq 0x3328(%rbx), %rdi
callq 0x4b358
movq %r15, %rdi
callq 0x4b12c
movq %rbp, %rdi
callq 0x4b0d8
movq 0x8(%rsp), %rdi
callq 0x4b12c
movq 0x10(%rsp), %rdi
callq 0x4b12c
movq 0x18(%rsp), %rdi
callq 0x4b0f2
movq 0x20(%rsp), %rdi
callq 0x4b12c
movq 0x28(%rsp), %rdi
callq 0x4b10c
movq 0x30(%rsp), %rdi
callq 0x48c3a
movq 0x38(%rsp), %rdi
callq 0x4b12c
movq %r13, %rdi
callq 0x563f4
jmp 0x494bd
movq %rax, (%rsp)
leaq 0x1cb8(%rbx), %rax
movq %rax, 0x38(%rsp)
leaq 0x1cc8(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x1cd8(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x1ce8(%rbx), %rax
movq %rax, 0x20(%rsp)
leaq 0x1cf8(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq 0x1ea8(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x1eb8(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0x1ec8(%rbx), %rax
movq %rax, 0x90(%rsp)
leaq 0x1ed8(%rbx), %rax
movq %rax, 0x88(%rsp)
leaq 0x1ee8(%rbx), %rax
movq %rax, 0x80(%rsp)
leaq 0x1ef8(%rbx), %rax
movq %rax, 0x78(%rsp)
leaq 0x1f08(%rbx), %rax
movq %rax, 0x70(%rsp)
leaq 0x1f18(%rbx), %rax
movq %rax, 0x68(%rsp)
leaq 0x1f28(%rbx), %rax
movq %rax, 0x60(%rsp)
leaq 0x2180(%rbx), %rax
movq %rax, 0x58(%rsp)
leaq 0x21b0(%rbx), %rax
movq %rax, 0x50(%rsp)
leaq 0x21c0(%rbx), %rax
movq %rax, 0x48(%rsp)
leaq 0x21e8(%rbx), %rax
movq %rax, 0x40(%rsp)
leaq 0x21f8(%rbx), %r15
leaq 0x2238(%rbx), %rbp
leaq 0x2248(%rbx), %r13
leaq 0x2260(%rbx), %rdi
callq 0x4b146
movq %r13, %rdi
callq 0x4b16a
movq %rbp, %rdi
callq 0x4b184
movq %r12, %rdi
callq 0x4b19e
movq %r15, %rdi
callq 0x4b0a4
movq 0x40(%rsp), %rdi
callq 0x4afea
movq 0x48(%rsp), %rdi
callq 0x4b1c2
movq 0x50(%rsp), %rdi
callq 0x4b1e6
movq 0x58(%rsp), %rdi
callq 0x4b200
movq 0x60(%rsp), %rdi
callq 0x4ac6a
movq 0x68(%rsp), %rdi
callq 0x4b21a
movq 0x70(%rsp), %rdi
callq 0x4b21a
movq 0x78(%rsp), %rdi
callq 0x4b234
movq 0x80(%rsp), %rdi
callq 0x4b24e
movq 0x88(%rsp), %rdi
callq 0x48c3a
movq 0x90(%rsp), %rdi
callq 0x4b268
movq 0x8(%rsp), %rdi
callq 0x4b282
movq 0x10(%rsp), %rdi
callq 0x4b29c
movq 0x18(%rsp), %rdi
callq 0x4b0be
movq 0x20(%rsp), %rdi
callq 0x4b2b6
movq 0x28(%rsp), %rdi
callq 0x4aad0
movq 0x30(%rsp), %rdi
callq 0x4aad0
movq 0x38(%rsp), %rdi
callq 0x4aad0
jmp 0x496a2
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x4b2d0
addq $0x1550, %rbx # imm = 0x1550
movq %rbx, %rdi
callq 0x485c2
movq (%rsp), %rdi
callq 0x243e0
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImGuiViewportP::ImGuiViewportP() | ImGuiViewportP() { Idx = -1; LastFrameActive = DrawListsLastFrame[0] = DrawListsLastFrame[1] = LastFrontMostStampCount = -1; LastNameHash = 0; Alpha = LastAlpha = 1.0f; PlatformMonitor = -1; PlatformWindowCreated = false; Window = NULL; DrawLists[0] = DrawLists[1] = NULL; LastPlatformPos = LastPlatformSize = LastRendererSize = ImVec2(FLT_MAX, FLT_MAX); } | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0xa0, %rdi
movl $0x90, %edx
xorl %esi, %esi
callq 0x241f0
orq $-0x1, 0x88(%rbx)
movaps 0x53674(%rip), %xmm0 # 0x9d260
movups %xmm0, 0x5c(%rbx)
movaps 0x53679(%rip), %xmm0 # 0x9d270
movups %xmm0, 0x6c(%rbx)
orw $-0x1, 0x7c(%rbx)
movb $0x0, 0x7e(%rbx)
andq $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movabsq $0x7f7fffff7f7fffff, %rax # imm = 0x7F7FFFFF7F7FFFFF
movq %rax, 0x108(%rbx)
movaps 0x535b2(%rip), %xmm0 # 0x9d1e0
movups %xmm0, 0xf8(%rbx)
popq %rbx
retq
nop
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImChunkStream<ImGuiWindowSettings>::next_chunk(ImGuiWindowSettings*) | T* next_chunk(T* p) { size_t HDR_SZ = 4; IM_ASSERT(p >= begin() && p < end()); p = (T*)(void*)((char*)(void*)p + chunk_size(p)); if (p == (T*)(void*)((char*)end() + HDR_SZ)) return (T*)0; IM_ASSERT(p < end()); return p; } | pushq %rax
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setne %al
leaq 0x4(%rcx), %rdx
cmpq %rsi, %rdx
seta %dl
testb %dl, %al
jne 0x4a870
movslq (%rdi), %rax
addq %rax, %rcx
cmpq %rsi, %rcx
jbe 0x4a870
movslq -0x4(%rsi), %rax
addq %rsi, %rax
leaq 0x4(%rcx), %rdx
cmpq %rdx, %rax
je 0x4a86c
cmpq %rcx, %rax
jb 0x4a86e
leaq 0x59027(%rip), %rdi # 0xa3891
jmp 0x4a877
xorl %eax, %eax
popq %rcx
retq
leaq 0x5900a(%rip), %rdi # 0xa3881
leaq 0x58ce8(%rip), %rsi # 0xa3566
leaq 0x5c5a4(%rip), %rcx # 0xa6e29
movl $0x29f, %edx # imm = 0x29F
callq 0x24110
nop
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImChunkStream<ImGuiTableSettings>::next_chunk(ImGuiTableSettings*) | T* next_chunk(T* p) { size_t HDR_SZ = 4; IM_ASSERT(p >= begin() && p < end()); p = (T*)(void*)((char*)(void*)p + chunk_size(p)); if (p == (T*)(void*)((char*)end() + HDR_SZ)) return (T*)0; IM_ASSERT(p < end()); return p; } | pushq %rax
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setne %al
leaq 0x4(%rcx), %rdx
cmpq %rsi, %rdx
seta %dl
testb %dl, %al
jne 0x4ad2a
movslq (%rdi), %rax
addq %rax, %rcx
cmpq %rsi, %rcx
jbe 0x4ad2a
movslq -0x4(%rsi), %rax
addq %rsi, %rax
leaq 0x4(%rcx), %rdx
cmpq %rdx, %rax
je 0x4ad26
cmpq %rcx, %rax
jb 0x4ad28
leaq 0x58b6d(%rip), %rdi # 0xa3891
jmp 0x4ad31
xorl %eax, %eax
popq %rcx
retq
leaq 0x58b50(%rip), %rdi # 0xa3881
leaq 0x5882e(%rip), %rsi # 0xa3566
leaq 0x5c323(%rip), %rcx # 0xa7062
movl $0x29f, %edx # imm = 0x29F
callq 0x24110
nop
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImGuiInputTextState::~ImGuiInputTextState() | struct IMGUI_API ImGuiInputTextState
{
ImGuiID ID; // widget id owning the text state
int CurLenW, CurLenA; // we need to maintain our buffer length in both UTF-8 and wchar format. UTF-8 length is valid even if TextA is not.
ImVector<ImWchar> TextW; // edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. so we copy into own buffer.
ImVector<char> TextA; // temporary UTF8 buffer for callbacks and other operations. this is not updated in every code-path! size=capacity.
ImVector<char> InitialTextA; // backup of end-user buffer at the time of focus (in UTF-8, unaltered)
bool TextAIsValid; // temporary UTF8 buffer is not initially valid before we make the widget active (until then we pull the data from user argument)
int BufCapacityA; // end-user buffer capacity
float ScrollX; // horizontal scrolling/offset
ImStb::STB_TexteditState Stb; // state for stb_textedit.h
float CursorAnim; // timer for cursor blink, reset on every user action so the cursor reappears immediately
bool CursorFollow; // set when we want scrolling to follow the current cursor position (not always!)
bool SelectedAllMouseLock; // after a double-click to select all, we ignore further mouse drags to update selection
bool Edited; // edited this frame
ImGuiInputTextFlags Flags; // copy of InputText() flags
ImGuiInputTextCallback UserCallback; // "
void* UserCallbackData; // "
ImGuiInputTextState() { memset(this, 0, sizeof(*this)); }
void ClearText() { CurLenW = CurLenA = 0; TextW[0] = 0; TextA[0] = 0; CursorClamp(); }
void ClearFreeMemory() { TextW.clear(); TextA.clear(); InitialTextA.clear(); }
int GetUndoAvailCount() const { return Stb.undostate.undo_point; }
int GetRedoAvailCount() const { return STB_TEXTEDIT_UNDOSTATECOUNT - Stb.undostate.redo_point; }
void OnKeyPressed(int key); // Cannot be inline because we call in code in stb_textedit.h implementation
// Cursor & Selection
void CursorAnimReset() { CursorAnim = -0.30f; } // After a user-input the cursor stays on for a while without blinking
void CursorClamp() { Stb.cursor = ImMin(Stb.cursor, CurLenW); Stb.select_start = ImMin(Stb.select_start, CurLenW); Stb.select_end = ImMin(Stb.select_end, CurLenW); }
bool HasSelection() const { return Stb.select_start != Stb.select_end; }
void ClearSelection() { Stb.select_start = Stb.select_end = Stb.cursor; }
int GetCursorPos() const { return Stb.cursor; }
int GetSelectionStart() const { return Stb.select_start; }
int GetSelectionEnd() const { return Stb.select_end; }
void SelectAll() { Stb.select_start = 0; Stb.cursor = Stb.select_end = CurLenW; Stb.has_preferred_x = 0; }
} | pushq %rbx
movq %rdi, %rbx
addq $0x30, %rdi
callq 0x4b12c
leaq 0x20(%rbx), %rdi
callq 0x4b12c
addq $0x10, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x485c2
nop
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImVector<ImGuiWindow*>::insert(ImGuiWindow* const*, ImGuiWindow* const&) | inline T* insert(const T* it, const T& v) { IM_ASSERT(it >= Data && it <= Data + Size); const ptrdiff_t off = it - Data; if (Size == Capacity) reserve(_grow_capacity(Size + 1)); if (off < (int)Size) memmove(Data + off + 1, Data + off, ((size_t)Size - (size_t)off) * sizeof(T)); memcpy(&Data[off], &v, sizeof(v)); Size++; return Data + off; } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rbx, %rsi
ja 0x4b631
movq %rdi, %r14
movslq (%rdi), %rcx
leaq (%rsi,%rcx,8), %rax
cmpq %rbx, %rax
jb 0x4b631
movq %rdx, %r15
subq %rsi, %rbx
movq %rbx, %r12
sarq $0x3, %r12
cmpl 0x4(%r14), %ecx
jne 0x4b5f4
leal 0x1(%rcx), %esi
testl %ecx, %ecx
je 0x4b5dd
pushq $0x2
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
addl %ecx, %eax
jmp 0x4b5e0
pushq $0x8
popq %rax
cmpl %esi, %eax
cmovgl %eax, %esi
movq %r14, %rdi
callq 0x4a06a
movslq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %r12, %rcx
jle 0x4b614
leaq (%rsi,%rbx), %rdi
addq $0x8, %rdi
addq %rbx, %rsi
shlq $0x3, %rcx
movq %rcx, %rdx
callq 0x24100
movq 0x8(%r14), %rsi
movq (%r15), %rax
movq %rax, (%rsi,%rbx)
incl (%r14)
addq 0x8(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x582c0(%rip), %rdi # 0xa38f8
leaq 0x57fc4(%rip), %rsi # 0xa3603
leaq 0x582d2(%rip), %rcx # 0xa3918
movl $0x720, %edx # imm = 0x720
callq 0x24110
| /binji[P]binjgb/third_party/imgui/imgui.h |
ImGuiTabBar::~ImGuiTabBar() | struct IMGUI_API ImGuiTabBar
{
ImVector<ImGuiTabItem> Tabs;
ImGuiTabBarFlags Flags;
ImGuiID ID; // Zero for tab-bars used by docking
ImGuiID SelectedTabId; // Selected tab/window
ImGuiID NextSelectedTabId; // Next selected tab/window. Will also trigger a scrolling animation
ImGuiID VisibleTabId; // Can occasionally be != SelectedTabId (e.g. when previewing contents for CTRL+TAB preview)
int CurrFrameVisible;
int PrevFrameVisible;
ImRect BarRect;
float CurrTabsContentsHeight;
float PrevTabsContentsHeight; // Record the height of contents submitted below the tab bar
float WidthAllTabs; // Actual width of all tabs (locked during layout)
float WidthAllTabsIdeal; // Ideal width if all tabs were visible and not clipped
float ScrollingAnim;
float ScrollingTarget;
float ScrollingTargetDistToVisibility;
float ScrollingSpeed;
float ScrollingRectMinX;
float ScrollingRectMaxX;
ImGuiID ReorderRequestTabId;
ImS16 ReorderRequestOffset;
ImS8 BeginCount;
bool WantLayout;
bool VisibleTabWasSubmitted;
bool TabsAddedNew; // Set to true when a new tab item or button has been added to the tab bar during last frame
ImS16 TabsActiveCount; // Number of tabs submitted this frame.
ImS16 LastTabItemIdx; // Index of last BeginTabItem() tab for use by EndTabItem()
float ItemSpacingY;
ImVec2 FramePadding; // style.FramePadding locked at the time of BeginTabBar()
ImVec2 BackupCursorPos;
ImGuiTextBuffer TabsNames; // For non-docking tab bar we re-append names in a contiguous buffer.
ImGuiTabBar();
int GetTabOrder(const ImGuiTabItem* tab) const { return Tabs.index_from_ptr(tab); }
const char* GetTabName(const ImGuiTabItem* tab) const
{
if (tab->Window)
return tab->Window->Name;
IM_ASSERT(tab->NameOffset != -1 && tab->NameOffset < TabsNames.Buf.Size);
return TabsNames.Buf.Data + tab->NameOffset;
}
} | pushq %rbx
movq %rdi, %rbx
addq $0x88, %rdi
callq 0x4b12c
movq %rbx, %rdi
popq %rbx
jmp 0x4c5ec
nop
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
ImGui::StyleColorsDark(ImGuiStyle*) | void ImGui::StyleColorsDark(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
colors[ImGuiCol_WindowBg] = ImVec4(0.06f, 0.06f, 0.06f, 0.94f);
colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_PopupBg] = ImVec4(0.08f, 0.08f, 0.08f, 0.94f);
colors[ImGuiCol_Border] = ImVec4(0.43f, 0.43f, 0.50f, 0.50f);
colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_FrameBg] = ImVec4(0.16f, 0.29f, 0.48f, 0.54f);
colors[ImGuiCol_FrameBgHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
colors[ImGuiCol_FrameBgActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
colors[ImGuiCol_TitleBg] = ImVec4(0.04f, 0.04f, 0.04f, 1.00f);
colors[ImGuiCol_TitleBgActive] = ImVec4(0.16f, 0.29f, 0.48f, 1.00f);
colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.00f, 0.00f, 0.00f, 0.51f);
colors[ImGuiCol_MenuBarBg] = ImVec4(0.14f, 0.14f, 0.14f, 1.00f);
colors[ImGuiCol_ScrollbarBg] = ImVec4(0.02f, 0.02f, 0.02f, 0.53f);
colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.31f, 0.31f, 0.31f, 1.00f);
colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);
colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.51f, 0.51f, 0.51f, 1.00f);
colors[ImGuiCol_CheckMark] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_SliderGrab] = ImVec4(0.24f, 0.52f, 0.88f, 1.00f);
colors[ImGuiCol_SliderGrabActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_Button] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
colors[ImGuiCol_ButtonHovered] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_ButtonActive] = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);
colors[ImGuiCol_Header] = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);
colors[ImGuiCol_HeaderHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);
colors[ImGuiCol_HeaderActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_Separator] = colors[ImGuiCol_Border];
colors[ImGuiCol_SeparatorHovered] = ImVec4(0.10f, 0.40f, 0.75f, 0.78f);
colors[ImGuiCol_SeparatorActive] = ImVec4(0.10f, 0.40f, 0.75f, 1.00f);
colors[ImGuiCol_ResizeGrip] = ImVec4(0.26f, 0.59f, 0.98f, 0.20f);
colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
colors[ImGuiCol_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.80f);
colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered];
colors[ImGuiCol_TabActive] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
colors[ImGuiCol_TabUnfocused] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f);
colors[ImGuiCol_TabUnfocusedActive] = ImLerp(colors[ImGuiCol_TabActive], colors[ImGuiCol_TitleBg], 0.40f);
colors[ImGuiCol_DockingPreview] = colors[ImGuiCol_HeaderActive] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);
colors[ImGuiCol_DockingEmptyBg] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
colors[ImGuiCol_PlotLines] = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
colors[ImGuiCol_TableHeaderBg] = ImVec4(0.19f, 0.19f, 0.20f, 1.00f);
colors[ImGuiCol_TableBorderStrong] = ImVec4(0.31f, 0.31f, 0.35f, 1.00f); // Prefer using Alpha=1.0 here
colors[ImGuiCol_TableBorderLight] = ImVec4(0.23f, 0.23f, 0.25f, 1.00f); // Prefer using Alpha=1.0 here
colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_TableRowBgAlt] = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);
colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
colors[ImGuiCol_NavHighlight] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4c829
callq 0x26f92
movq %rax, %rbx
movaps 0x50b20(%rip), %xmm0 # 0x9d350
movups %xmm0, 0xc8(%rbx)
movaps 0x5a9c2(%rip), %xmm0 # 0xa7200
movups %xmm0, 0xd8(%rbx)
movaps 0x5a9c4(%rip), %xmm0 # 0xa7210
movups %xmm0, 0xe8(%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0xf8(%rbx)
movaps 0x5a9bc(%rip), %xmm0 # 0xa7220
movups %xmm0, 0x108(%rbx)
movaps 0x5a9be(%rip), %xmm0 # 0xa7230
movups %xmm0, 0x118(%rbx)
movups %xmm1, 0x128(%rbx)
movaps 0x5a9b9(%rip), %xmm0 # 0xa7240
movups %xmm0, 0x138(%rbx)
movaps 0x5a9bb(%rip), %xmm1 # 0xa7250
movups %xmm1, 0x148(%rbx)
movaps 0x5a9bd(%rip), %xmm0 # 0xa7260
movups %xmm0, 0x158(%rbx)
leaq 0x168(%rbx), %r14
movaps 0x5a9b8(%rip), %xmm2 # 0xa7270
movups %xmm2, 0x168(%rbx)
leaq 0x178(%rbx), %r12
movaps 0x5a9b3(%rip), %xmm2 # 0xa7280
movups %xmm2, 0x178(%rbx)
movaps 0x5a9b5(%rip), %xmm2 # 0xa7290
movups %xmm2, 0x188(%rbx)
movaps 0x5a9b7(%rip), %xmm2 # 0xa72a0
movups %xmm2, 0x198(%rbx)
movaps 0x5a9b9(%rip), %xmm2 # 0xa72b0
movups %xmm2, 0x1a8(%rbx)
movaps 0x5a9bb(%rip), %xmm2 # 0xa72c0
movups %xmm2, 0x1b8(%rbx)
movaps 0x5a9bd(%rip), %xmm2 # 0xa72d0
movups %xmm2, 0x1c8(%rbx)
movaps 0x5a9bf(%rip), %xmm2 # 0xa72e0
movups %xmm2, 0x1d8(%rbx)
movaps 0x5a9c1(%rip), %xmm3 # 0xa72f0
movups %xmm3, 0x1e8(%rbx)
movaps 0x5a9c3(%rip), %xmm2 # 0xa7300
movups %xmm2, 0x1f8(%rbx)
movups %xmm3, 0x208(%rbx)
movups %xmm1, 0x218(%rbx)
movups %xmm3, 0x228(%rbx)
movaps 0x5a9b0(%rip), %xmm1 # 0xa7310
movups %xmm1, 0x238(%rbx)
leaq 0x248(%rbx), %rdi
movaps 0x5a9ab(%rip), %xmm1 # 0xa7320
movups %xmm1, 0x248(%rbx)
movaps 0x5a9ad(%rip), %xmm1 # 0xa7330
movups %xmm1, 0x258(%rbx)
leaq 0x268(%rbx), %r15
movups %xmm3, 0x268(%rbx)
movups 0x118(%rbx), %xmm1
movups %xmm1, 0x278(%rbx)
movaps 0x5a993(%rip), %xmm1 # 0xa7340
movups %xmm1, 0x288(%rbx)
movaps 0x5a995(%rip), %xmm1 # 0xa7350
movups %xmm1, 0x298(%rbx)
movaps 0x5a997(%rip), %xmm1 # 0xa7360
movups %xmm1, 0x2a8(%rbx)
movups %xmm0, 0x2b8(%rbx)
movaps 0x5a992(%rip), %xmm0 # 0xa7370
movups %xmm0, 0x2c8(%rbx)
movss 0x50a83(%rip), %xmm0 # 0x9d470
movq %r12, %rsi
callq 0x4cb7b
leaq 0x2d8(%rbx), %r13
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x2d8(%rbx)
movups 0x258(%rbx), %xmm0
movups %xmm0, 0x2e8(%rbx)
movss 0x50a6c(%rip), %xmm0 # 0x9d488
movq %r15, %rdi
movq %r12, %rsi
callq 0x4cb7b
leaq 0x2f8(%rbx), %r12
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x2f8(%rbx)
movq %r13, %rdi
movq %r14, %rsi
movss 0x50a2a(%rip), %xmm0 # 0x9d470
callq 0x4cb7b
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x308(%rbx)
movss 0x50a3f(%rip), %xmm0 # 0x9d49c
movq %r12, %rdi
movq %r14, %rsi
callq 0x4cb7b
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x318(%rbx)
movaps 0x5a907(%rip), %xmm0 # 0xa7380
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r15, %rdi
callq 0x4cb96
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x328(%rbx)
movaps 0x5a8f8(%rip), %xmm0 # 0xa7390
movups %xmm0, 0x338(%rbx)
movaps 0x5a8fa(%rip), %xmm0 # 0xa73a0
movups %xmm0, 0x348(%rbx)
movaps 0x5a8fc(%rip), %xmm0 # 0xa73b0
movups %xmm0, 0x358(%rbx)
movaps 0x5a8fe(%rip), %xmm0 # 0xa73c0
movups %xmm0, 0x368(%rbx)
movaps 0x5a900(%rip), %xmm0 # 0xa73d0
movups %xmm0, 0x378(%rbx)
movaps 0x5a902(%rip), %xmm0 # 0xa73e0
movups %xmm0, 0x388(%rbx)
movaps 0x5a904(%rip), %xmm0 # 0xa73f0
movups %xmm0, 0x398(%rbx)
movaps 0x5a906(%rip), %xmm0 # 0xa7400
movups %xmm0, 0x3a8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x3b8(%rbx)
movaps 0x5a8fe(%rip), %xmm0 # 0xa7410
movups %xmm0, 0x3c8(%rbx)
movaps 0x5a900(%rip), %xmm0 # 0xa7420
movups %xmm0, 0x3d8(%rbx)
movaps 0x5a902(%rip), %xmm0 # 0xa7430
movups %xmm0, 0x3e8(%rbx)
movaps 0x5a7b4(%rip), %xmm0 # 0xa72f0
movups %xmm0, 0x3f8(%rbx)
movaps 0x5a836(%rip), %xmm0 # 0xa7380
movups %xmm0, 0x408(%rbx)
movaps 0x5a8e8(%rip), %xmm0 # 0xa7440
movups %xmm0, 0x418(%rbx)
movaps 0x5a8ea(%rip), %xmm0 # 0xa7450
movups %xmm0, 0x428(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /binji[P]binjgb/third_party/imgui/imgui_draw.cpp |
ImGui::StyleColorsClassic(ImGuiStyle*) | void ImGui::StyleColorsClassic(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(0.90f, 0.90f, 0.90f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
colors[ImGuiCol_WindowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.85f);
colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_PopupBg] = ImVec4(0.11f, 0.11f, 0.14f, 0.92f);
colors[ImGuiCol_Border] = ImVec4(0.50f, 0.50f, 0.50f, 0.50f);
colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_FrameBg] = ImVec4(0.43f, 0.43f, 0.43f, 0.39f);
colors[ImGuiCol_FrameBgHovered] = ImVec4(0.47f, 0.47f, 0.69f, 0.40f);
colors[ImGuiCol_FrameBgActive] = ImVec4(0.42f, 0.41f, 0.64f, 0.69f);
colors[ImGuiCol_TitleBg] = ImVec4(0.27f, 0.27f, 0.54f, 0.83f);
colors[ImGuiCol_TitleBgActive] = ImVec4(0.32f, 0.32f, 0.63f, 0.87f);
colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.40f, 0.40f, 0.80f, 0.20f);
colors[ImGuiCol_MenuBarBg] = ImVec4(0.40f, 0.40f, 0.55f, 0.80f);
colors[ImGuiCol_ScrollbarBg] = ImVec4(0.20f, 0.25f, 0.30f, 0.60f);
colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.40f, 0.40f, 0.80f, 0.30f);
colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.40f, 0.40f, 0.80f, 0.40f);
colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.41f, 0.39f, 0.80f, 0.60f);
colors[ImGuiCol_CheckMark] = ImVec4(0.90f, 0.90f, 0.90f, 0.50f);
colors[ImGuiCol_SliderGrab] = ImVec4(1.00f, 1.00f, 1.00f, 0.30f);
colors[ImGuiCol_SliderGrabActive] = ImVec4(0.41f, 0.39f, 0.80f, 0.60f);
colors[ImGuiCol_Button] = ImVec4(0.35f, 0.40f, 0.61f, 0.62f);
colors[ImGuiCol_ButtonHovered] = ImVec4(0.40f, 0.48f, 0.71f, 0.79f);
colors[ImGuiCol_ButtonActive] = ImVec4(0.46f, 0.54f, 0.80f, 1.00f);
colors[ImGuiCol_Header] = ImVec4(0.40f, 0.40f, 0.90f, 0.45f);
colors[ImGuiCol_HeaderHovered] = ImVec4(0.45f, 0.45f, 0.90f, 0.80f);
colors[ImGuiCol_HeaderActive] = ImVec4(0.53f, 0.53f, 0.87f, 0.80f);
colors[ImGuiCol_Separator] = ImVec4(0.50f, 0.50f, 0.50f, 0.60f);
colors[ImGuiCol_SeparatorHovered] = ImVec4(0.60f, 0.60f, 0.70f, 1.00f);
colors[ImGuiCol_SeparatorActive] = ImVec4(0.70f, 0.70f, 0.90f, 1.00f);
colors[ImGuiCol_ResizeGrip] = ImVec4(1.00f, 1.00f, 1.00f, 0.10f);
colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.78f, 0.82f, 1.00f, 0.60f);
colors[ImGuiCol_ResizeGripActive] = ImVec4(0.78f, 0.82f, 1.00f, 0.90f);
colors[ImGuiCol_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.80f);
colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered];
colors[ImGuiCol_TabActive] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
colors[ImGuiCol_TabUnfocused] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f);
colors[ImGuiCol_TabUnfocusedActive] = ImLerp(colors[ImGuiCol_TabActive], colors[ImGuiCol_TitleBg], 0.40f);
colors[ImGuiCol_DockingPreview] = colors[ImGuiCol_Header] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);
colors[ImGuiCol_DockingEmptyBg] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
colors[ImGuiCol_PlotLines] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
colors[ImGuiCol_PlotLinesHovered] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
colors[ImGuiCol_TableHeaderBg] = ImVec4(0.27f, 0.27f, 0.38f, 1.00f);
colors[ImGuiCol_TableBorderStrong] = ImVec4(0.31f, 0.31f, 0.45f, 1.00f); // Prefer using Alpha=1.0 here
colors[ImGuiCol_TableBorderLight] = ImVec4(0.26f, 0.26f, 0.28f, 1.00f); // Prefer using Alpha=1.0 here
colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_TableRowBgAlt] = ImVec4(1.00f, 1.00f, 1.00f, 0.07f);
colors[ImGuiCol_TextSelectedBg] = ImVec4(0.00f, 0.00f, 1.00f, 0.35f);
colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
colors[ImGuiCol_NavHighlight] = colors[ImGuiCol_HeaderHovered];
colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4cbc5
callq 0x26f92
movq %rax, %rbx
movaps 0x5a894(%rip), %xmm0 # 0xa7460
movups %xmm0, 0xc8(%rbx)
movaps 0x5a896(%rip), %xmm0 # 0xa7470
movups %xmm0, 0xd8(%rbx)
movaps 0x5a898(%rip), %xmm0 # 0xa7480
movups %xmm0, 0xe8(%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0xf8(%rbx)
movaps 0x5a890(%rip), %xmm0 # 0xa7490
movups %xmm0, 0x108(%rbx)
movaps 0x50642(%rip), %xmm0 # 0x9d250
movups %xmm0, 0x118(%rbx)
movups %xmm1, 0x128(%rbx)
movaps 0x5a87d(%rip), %xmm0 # 0xa74a0
movups %xmm0, 0x138(%rbx)
movaps 0x5a87f(%rip), %xmm0 # 0xa74b0
movups %xmm0, 0x148(%rbx)
movaps 0x5a881(%rip), %xmm0 # 0xa74c0
movups %xmm0, 0x158(%rbx)
leaq 0x168(%rbx), %r14
movaps 0x5a87c(%rip), %xmm0 # 0xa74d0
movups %xmm0, 0x168(%rbx)
leaq 0x178(%rbx), %r12
movaps 0x5a877(%rip), %xmm0 # 0xa74e0
movups %xmm0, 0x178(%rbx)
movaps 0x5a879(%rip), %xmm0 # 0xa74f0
movups %xmm0, 0x188(%rbx)
movaps 0x5a87b(%rip), %xmm0 # 0xa7500
movups %xmm0, 0x198(%rbx)
movaps 0x5a87d(%rip), %xmm0 # 0xa7510
movups %xmm0, 0x1a8(%rbx)
movaps 0x5a87f(%rip), %xmm0 # 0xa7520
movups %xmm0, 0x1b8(%rbx)
movaps 0x5a881(%rip), %xmm0 # 0xa7530
movups %xmm0, 0x1c8(%rbx)
movaps 0x5a883(%rip), %xmm0 # 0xa7540
movups %xmm0, 0x1d8(%rbx)
movaps 0x5a885(%rip), %xmm1 # 0xa7550
movups %xmm1, 0x1e8(%rbx)
movaps 0x5a887(%rip), %xmm1 # 0xa7560
movups %xmm1, 0x1f8(%rbx)
movups %xmm0, 0x208(%rbx)
movaps 0x5a882(%rip), %xmm0 # 0xa7570
movups %xmm0, 0x218(%rbx)
movaps 0x5a884(%rip), %xmm0 # 0xa7580
movups %xmm0, 0x228(%rbx)
movaps 0x5a886(%rip), %xmm0 # 0xa7590
movups %xmm0, 0x238(%rbx)
leaq 0x248(%rbx), %r15
movaps 0x5a881(%rip), %xmm0 # 0xa75a0
movups %xmm0, 0x248(%rbx)
movaps 0x5a883(%rip), %xmm0 # 0xa75b0
movups %xmm0, 0x258(%rbx)
leaq 0x268(%rbx), %r13
movaps 0x5a87e(%rip), %xmm0 # 0xa75c0
movups %xmm0, 0x268(%rbx)
movaps 0x5a880(%rip), %xmm0 # 0xa75d0
movups %xmm0, 0x278(%rbx)
movaps 0x5a882(%rip), %xmm0 # 0xa75e0
movups %xmm0, 0x288(%rbx)
movaps 0x5a884(%rip), %xmm0 # 0xa75f0
movups %xmm0, 0x298(%rbx)
movaps 0x5a886(%rip), %xmm0 # 0xa7600
movups %xmm0, 0x2a8(%rbx)
movaps 0x5a888(%rip), %xmm0 # 0xa7610
movups %xmm0, 0x2b8(%rbx)
movaps 0x5a88a(%rip), %xmm0 # 0xa7620
movups %xmm0, 0x2c8(%rbx)
movss 0x506cb(%rip), %xmm0 # 0x9d470
movq %r15, %rdi
movq %r12, %rsi
callq 0x4cb7b
leaq 0x2d8(%rbx), %rbp
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x2d8(%rbx)
movups 0x258(%rbx), %xmm0
movups %xmm0, 0x2e8(%rbx)
movss 0x506b1(%rip), %xmm0 # 0x9d488
movq %r13, %rdi
movq %r12, %rsi
callq 0x4cb7b
leaq 0x2f8(%rbx), %r12
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x2f8(%rbx)
movq %rbp, %rdi
movq %r14, %rsi
movss 0x5066f(%rip), %xmm0 # 0x9d470
callq 0x4cb7b
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x308(%rbx)
movss 0x50684(%rip), %xmm0 # 0x9d49c
movq %r12, %rdi
movq %r14, %rsi
callq 0x4cb7b
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x318(%rbx)
movaps 0x5a54c(%rip), %xmm0 # 0xa7380
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r15, %rdi
callq 0x4cb96
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x328(%rbx)
movaps 0x5a53d(%rip), %xmm0 # 0xa7390
movups %xmm0, 0x338(%rbx)
movaps 0x504ef(%rip), %xmm0 # 0x9d350
movups %xmm0, 0x348(%rbx)
movaps 0x5a551(%rip), %xmm0 # 0xa73c0
movups %xmm0, 0x358(%rbx)
movups %xmm0, 0x368(%rbx)
movaps 0x5a54c(%rip), %xmm0 # 0xa73d0
movups %xmm0, 0x378(%rbx)
movaps 0x5a79e(%rip), %xmm0 # 0xa7630
movups %xmm0, 0x388(%rbx)
movaps 0x5a7a0(%rip), %xmm0 # 0xa7640
movups %xmm0, 0x398(%rbx)
movaps 0x5a7a2(%rip), %xmm0 # 0xa7650
movups %xmm0, 0x3a8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x3b8(%rbx)
movaps 0x5a79a(%rip), %xmm0 # 0xa7660
movups %xmm0, 0x3c8(%rbx)
movaps 0x5a79c(%rip), %xmm0 # 0xa7670
movups %xmm0, 0x3d8(%rbx)
movaps 0x5a54e(%rip), %xmm0 # 0xa7430
movups %xmm0, 0x3e8(%rbx)
movups 0x258(%rbx), %xmm0
movups %xmm0, 0x3f8(%rbx)
movaps 0x5a482(%rip), %xmm0 # 0xa7380
movups %xmm0, 0x408(%rbx)
movaps 0x5a534(%rip), %xmm0 # 0xa7440
movups %xmm0, 0x418(%rbx)
movaps 0x5a766(%rip), %xmm0 # 0xa7680
movups %xmm0, 0x428(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /binji[P]binjgb/third_party/imgui/imgui_draw.cpp |
ImGui::StyleColorsLight(ImGuiStyle*) | void ImGui::StyleColorsLight(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
colors[ImGuiCol_WindowBg] = ImVec4(0.94f, 0.94f, 0.94f, 1.00f);
colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_PopupBg] = ImVec4(1.00f, 1.00f, 1.00f, 0.98f);
colors[ImGuiCol_Border] = ImVec4(0.00f, 0.00f, 0.00f, 0.30f);
colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_FrameBg] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
colors[ImGuiCol_FrameBgHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
colors[ImGuiCol_FrameBgActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
colors[ImGuiCol_TitleBg] = ImVec4(0.96f, 0.96f, 0.96f, 1.00f);
colors[ImGuiCol_TitleBgActive] = ImVec4(0.82f, 0.82f, 0.82f, 1.00f);
colors[ImGuiCol_TitleBgCollapsed] = ImVec4(1.00f, 1.00f, 1.00f, 0.51f);
colors[ImGuiCol_MenuBarBg] = ImVec4(0.86f, 0.86f, 0.86f, 1.00f);
colors[ImGuiCol_ScrollbarBg] = ImVec4(0.98f, 0.98f, 0.98f, 0.53f);
colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.69f, 0.69f, 0.69f, 0.80f);
colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.49f, 0.49f, 0.49f, 0.80f);
colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.49f, 0.49f, 0.49f, 1.00f);
colors[ImGuiCol_CheckMark] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_SliderGrab] = ImVec4(0.26f, 0.59f, 0.98f, 0.78f);
colors[ImGuiCol_SliderGrabActive] = ImVec4(0.46f, 0.54f, 0.80f, 0.60f);
colors[ImGuiCol_Button] = ImVec4(0.26f, 0.59f, 0.98f, 0.40f);
colors[ImGuiCol_ButtonHovered] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_ButtonActive] = ImVec4(0.06f, 0.53f, 0.98f, 1.00f);
colors[ImGuiCol_Header] = ImVec4(0.26f, 0.59f, 0.98f, 0.31f);
colors[ImGuiCol_HeaderHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.80f);
colors[ImGuiCol_HeaderActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
colors[ImGuiCol_Separator] = ImVec4(0.39f, 0.39f, 0.39f, 0.62f);
colors[ImGuiCol_SeparatorHovered] = ImVec4(0.14f, 0.44f, 0.80f, 0.78f);
colors[ImGuiCol_SeparatorActive] = ImVec4(0.14f, 0.44f, 0.80f, 1.00f);
colors[ImGuiCol_ResizeGrip] = ImVec4(0.35f, 0.35f, 0.35f, 0.17f);
colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
colors[ImGuiCol_Tab] = ImLerp(colors[ImGuiCol_Header], colors[ImGuiCol_TitleBgActive], 0.90f);
colors[ImGuiCol_TabHovered] = colors[ImGuiCol_HeaderHovered];
colors[ImGuiCol_TabActive] = ImLerp(colors[ImGuiCol_HeaderActive], colors[ImGuiCol_TitleBgActive], 0.60f);
colors[ImGuiCol_TabUnfocused] = ImLerp(colors[ImGuiCol_Tab], colors[ImGuiCol_TitleBg], 0.80f);
colors[ImGuiCol_TabUnfocusedActive] = ImLerp(colors[ImGuiCol_TabActive], colors[ImGuiCol_TitleBg], 0.40f);
colors[ImGuiCol_DockingPreview] = colors[ImGuiCol_Header] * ImVec4(1.0f, 1.0f, 1.0f, 0.7f);
colors[ImGuiCol_DockingEmptyBg] = ImVec4(0.20f, 0.20f, 0.20f, 1.00f);
colors[ImGuiCol_PlotLines] = ImVec4(0.39f, 0.39f, 0.39f, 1.00f);
colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.45f, 0.00f, 1.00f);
colors[ImGuiCol_TableHeaderBg] = ImVec4(0.78f, 0.87f, 0.98f, 1.00f);
colors[ImGuiCol_TableBorderStrong] = ImVec4(0.57f, 0.57f, 0.64f, 1.00f); // Prefer using Alpha=1.0 here
colors[ImGuiCol_TableBorderLight] = ImVec4(0.68f, 0.68f, 0.74f, 1.00f); // Prefer using Alpha=1.0 here
colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
colors[ImGuiCol_TableRowBgAlt] = ImVec4(0.30f, 0.30f, 0.30f, 0.09f);
colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
colors[ImGuiCol_DragDropTarget] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
colors[ImGuiCol_NavHighlight] = colors[ImGuiCol_HeaderHovered];
colors[ImGuiCol_NavWindowingHighlight] = ImVec4(0.70f, 0.70f, 0.70f, 0.70f);
colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.20f);
colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.20f, 0.20f, 0.20f, 0.35f);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x4cf4e
callq 0x26f92
movq %rax, %rbx
movaps 0x5a73b(%rip), %xmm0 # 0xa7690
movups %xmm0, 0xc8(%rbx)
movaps 0x5a50d(%rip), %xmm0 # 0xa7470
movups %xmm0, 0xd8(%rbx)
movaps 0x5a72f(%rip), %xmm0 # 0xa76a0
movups %xmm0, 0xe8(%rbx)
xorps %xmm1, %xmm1
movups %xmm1, 0xf8(%rbx)
movaps 0x5a727(%rip), %xmm0 # 0xa76b0
movups %xmm0, 0x108(%rbx)
movaps 0x5a729(%rip), %xmm0 # 0xa76c0
movups %xmm0, 0x118(%rbx)
movups %xmm1, 0x128(%rbx)
movaps 0x503a4(%rip), %xmm0 # 0x9d350
movups %xmm0, 0x138(%rbx)
movaps 0x5a296(%rip), %xmm1 # 0xa7250
movups %xmm1, 0x148(%rbx)
movaps 0x5a298(%rip), %xmm0 # 0xa7260
movups %xmm0, 0x158(%rbx)
leaq 0x168(%rbx), %r14
movaps 0x5a6f3(%rip), %xmm2 # 0xa76d0
movups %xmm2, 0x168(%rbx)
leaq 0x178(%rbx), %r12
movaps 0x5a6ee(%rip), %xmm2 # 0xa76e0
movups %xmm2, 0x178(%rbx)
movaps 0x5a6f0(%rip), %xmm2 # 0xa76f0
movups %xmm2, 0x188(%rbx)
movaps 0x5a6f2(%rip), %xmm2 # 0xa7700
movups %xmm2, 0x198(%rbx)
movaps 0x5a6f4(%rip), %xmm2 # 0xa7710
movups %xmm2, 0x1a8(%rbx)
movaps 0x5a6f6(%rip), %xmm2 # 0xa7720
movups %xmm2, 0x1b8(%rbx)
movaps 0x5a6f8(%rip), %xmm2 # 0xa7730
movups %xmm2, 0x1c8(%rbx)
movaps 0x5a6fa(%rip), %xmm2 # 0xa7740
movups %xmm2, 0x1d8(%rbx)
movaps 0x5a29c(%rip), %xmm2 # 0xa72f0
movups %xmm2, 0x1e8(%rbx)
movaps 0x5a6ee(%rip), %xmm3 # 0xa7750
movups %xmm3, 0x1f8(%rbx)
movaps 0x5a6f0(%rip), %xmm3 # 0xa7760
movups %xmm3, 0x208(%rbx)
movups %xmm1, 0x218(%rbx)
movups %xmm2, 0x228(%rbx)
movaps 0x5a284(%rip), %xmm1 # 0xa7310
movups %xmm1, 0x238(%rbx)
leaq 0x248(%rbx), %r15
movaps 0x5a27f(%rip), %xmm1 # 0xa7320
movups %xmm1, 0x248(%rbx)
movaps 0x5a281(%rip), %xmm1 # 0xa7330
movups %xmm1, 0x258(%rbx)
leaq 0x268(%rbx), %r13
movups %xmm2, 0x268(%rbx)
movaps 0x5a6a5(%rip), %xmm1 # 0xa7770
movups %xmm1, 0x278(%rbx)
movaps 0x5a6a7(%rip), %xmm1 # 0xa7780
movups %xmm1, 0x288(%rbx)
movaps 0x5a6a9(%rip), %xmm1 # 0xa7790
movups %xmm1, 0x298(%rbx)
movaps 0x5a6ab(%rip), %xmm1 # 0xa77a0
movups %xmm1, 0x2a8(%rbx)
movups %xmm0, 0x2b8(%rbx)
movaps 0x5a266(%rip), %xmm0 # 0xa7370
movups %xmm0, 0x2c8(%rbx)
movss 0x5038f(%rip), %xmm0 # 0x9d4a8
movq %r15, %rdi
movq %r12, %rsi
callq 0x4cb7b
leaq 0x2d8(%rbx), %rbp
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x2d8(%rbx)
movups 0x258(%rbx), %xmm0
movups %xmm0, 0x2e8(%rbx)
movss 0x5033d(%rip), %xmm0 # 0x9d488
movq %r13, %rdi
movq %r12, %rsi
callq 0x4cb7b
leaq 0x2f8(%rbx), %r12
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x2f8(%rbx)
movss 0x50301(%rip), %xmm0 # 0x9d470
movq %rbp, %rdi
movq %r14, %rsi
callq 0x4cb7b
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x308(%rbx)
movss 0x50310(%rip), %xmm0 # 0x9d49c
movq %r12, %rdi
movq %r14, %rsi
callq 0x4cb7b
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x318(%rbx)
movaps 0x5a1d8(%rip), %xmm0 # 0xa7380
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %r15, %rdi
callq 0x4cb96
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x328(%rbx)
movaps 0x5a1c9(%rip), %xmm0 # 0xa7390
movups %xmm0, 0x338(%rbx)
movaps 0x5a5db(%rip), %xmm0 # 0xa77b0
movups %xmm0, 0x348(%rbx)
movaps 0x5a1cd(%rip), %xmm0 # 0xa73b0
movups %xmm0, 0x358(%rbx)
movaps 0x5a1cf(%rip), %xmm0 # 0xa73c0
movups %xmm0, 0x368(%rbx)
movaps 0x5a5c1(%rip), %xmm0 # 0xa77c0
movups %xmm0, 0x378(%rbx)
movaps 0x5a5c3(%rip), %xmm0 # 0xa77d0
movups %xmm0, 0x388(%rbx)
movaps 0x5a5c5(%rip), %xmm0 # 0xa77e0
movups %xmm0, 0x398(%rbx)
movaps 0x5a5c7(%rip), %xmm0 # 0xa77f0
movups %xmm0, 0x3a8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x3b8(%rbx)
movaps 0x5a5bf(%rip), %xmm0 # 0xa7800
movups %xmm0, 0x3c8(%rbx)
movaps 0x5a1d1(%rip), %xmm0 # 0xa7420
movups %xmm0, 0x3d8(%rbx)
movaps 0x5a113(%rip), %xmm0 # 0xa7370
movups %xmm0, 0x3e8(%rbx)
movups 0x258(%rbx), %xmm0
movups %xmm0, 0x3f8(%rbx)
movaps 0x5a597(%rip), %xmm0 # 0xa7810
movups %xmm0, 0x408(%rbx)
movaps 0x5a599(%rip), %xmm0 # 0xa7820
movups %xmm0, 0x418(%rbx)
movaps 0x5a3eb(%rip), %xmm0 # 0xa7680
movups %xmm0, 0x428(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /binji[P]binjgb/third_party/imgui/imgui_draw.cpp |
ImDrawListSharedData::ImDrawListSharedData() | ImDrawListSharedData::ImDrawListSharedData()
{
memset(this, 0, sizeof(*this));
for (int i = 0; i < IM_ARRAYSIZE(ArcFastVtx); i++)
{
const float a = ((float)i * 2 * IM_PI) / (float)IM_ARRAYSIZE(ArcFastVtx);
ArcFastVtx[i] = ImVec2(ImCos(a), ImSin(a));
}
ArcFastRadiusCutoff = IM_DRAWLIST_CIRCLE_AUTO_SEGMENT_CALC_R(IM_DRAWLIST_ARCFAST_SAMPLE_MAX, CircleSegmentMaxError);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0x241f0
cmpq $0x30, %r14
je 0x4d314
cvtsi2ss %r14d, %xmm0
addss %xmm0, %xmm0
mulss 0x5a5f7(%rip), %xmm0 # 0xa78d0
divss 0x5a5f3(%rip), %xmm0 # 0xa78d4
movss %xmm0, (%rsp)
callq 0x24440
movss %xmm0, 0x4(%rsp)
movss (%rsp), %xmm0
callq 0x24040
movss 0x4(%rsp), %xmm1
movss %xmm1, 0x30(%rbx,%r14,8)
movss %xmm0, 0x34(%rbx,%r14,8)
incq %r14
jmp 0x4d2c2
movss 0x18(%rbx), %xmm0
divss 0x5a5b7(%rip), %xmm0 # 0xa78d8
movss %xmm0, 0x1b0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /binji[P]binjgb/third_party/imgui/imgui_draw.cpp |
ImBitArraySetBitRange(unsigned int*, int, int) | inline void ImBitArraySetBitRange(ImU32* arr, int n, int n2) // Works on range [n..n2)
{
n2--;
while (n <= n2)
{
int a_mod = (n & 31);
int b_mod = (n2 > (n | 31) ? 31 : (n2 & 31)) + 1;
ImU32 mask = (ImU32)(((ImU64)1 << b_mod) - 1) & ~(ImU32)(((ImU64)1 << a_mod) - 1);
arr[n >> 5] |= mask;
n = (n + 32) & ~31;
}
} | leal -0x1(%rdx), %eax
movl %eax, %r8d
andl $0x1f, %r8d
incl %r8d
pushq $0x20
popq %r9
pushq $-0x1
popq %r10
cmpl %edx, %esi
jge 0x64776
movl %esi, %ecx
orl $0x1f, %ecx
cmpl %ecx, %eax
movl %r8d, %ecx
cmovgl %r9d, %ecx
movq %r10, %r11
shlq %cl, %r11
notl %r11d
movl %esi, %ecx
shrl %cl, %r11d
shll %cl, %r11d
movl %esi, %ecx
sarl $0x5, %ecx
movslq %ecx, %rcx
orl %r11d, (%rdi,%rcx,4)
andl $-0x20, %esi
addl $0x20, %esi
jmp 0x6473f
retq
nop
| /binji[P]binjgb/third_party/imgui/imgui_internal.h |
init_emulator | Result init_emulator(Emulator* e, const EmulatorInit* init) {
static u8 s_initial_wave_ram[WAVE_RAM_SIZE] = {
0x60, 0x0d, 0xda, 0xdd, 0x50, 0x0f, 0xad, 0xed,
0xc0, 0xde, 0xf0, 0x0d, 0xbe, 0xef, 0xfe, 0xed,
};
CHECK(SUCCESS(get_cart_infos(e)));
log_cart_info(e->cart_info);
MMAP_STATE.rom_base[0] = 0;
MMAP_STATE.rom_base[1] = 1 << ROM_BANK_SHIFT;
IS_CGB = !init->force_dmg && (e->cart_info->cgb_flag == CGB_FLAG_SUPPORTED ||
e->cart_info->cgb_flag == CGB_FLAG_REQUIRED);
IS_SGB = !init->force_dmg && !IS_CGB &&
e->cart_info->sgb_flag == SGB_FLAG_SUPPORTED;
set_af_reg(e, 0xb0);
REG.A = IS_CGB ? 0x11 : 0x01;
REG.BC = 0x0013;
REG.DE = 0x00d8;
REG.HL = 0x014d;
REG.SP = 0xfffe;
REG.PC = 0x0100;
INTR.ime = FALSE;
TIMER.div_counter = 0xAC00;
TIMER.next_intr_ticks = SERIAL.next_intr_ticks = e->state.next_intr_ticks =
INVALID_TICKS;
WRAM.offset = 0x1000;
/* Enable apu first, so subsequent writes succeed. */
write_apu(e, APU_NR52_ADDR, 0xf1);
write_apu(e, APU_NR11_ADDR, 0x80);
write_apu(e, APU_NR12_ADDR, 0xf3);
write_apu(e, APU_NR14_ADDR, 0x80);
write_apu(e, APU_NR50_ADDR, 0x77);
write_apu(e, APU_NR51_ADDR, 0xf3);
APU.initialized = TRUE;
memcpy(&WAVE.ram, s_initial_wave_ram, WAVE_RAM_SIZE);
/* Turn down the volume on channel1, it is playing by default (because of the
* GB startup sound), but we don't want to hear it when starting the
* emulator. */
CHANNEL1.envelope.volume = 0;
write_io(e, IO_LCDC_ADDR, 0x91);
write_io(e, IO_SCY_ADDR, 0x00);
write_io(e, IO_SCX_ADDR, 0x00);
write_io(e, IO_LYC_ADDR, 0x00);
write_io(e, IO_BGP_ADDR, 0xfc);
write_io(e, IO_OBP0_ADDR, 0xff);
write_io(e, IO_OBP1_ADDR, 0xff);
write_io(e, IO_IF_ADDR, 0x1);
write_io(e, IO_IE_ADDR, 0x0);
HDMA.blocks = 0xff;
/* Set initial DMG/SGB palettes */
emulator_set_builtin_palette(e, init->builtin_palette);
/* Set up cgb color curve */
e->cgb_color_curve = init->cgb_color_curve;
/* Set initial CGB palettes to white. */
int pal_index;
for (pal_index = 0; pal_index < 2; ++pal_index) {
ColorPalettes* palette = pal_index == 0 ? &PPU.bgcp : &PPU.obcp;
int i;
for (i = 0; i < 32; ++i) {
palette->palettes[i >> 2].color[i & 3] = RGBA_WHITE;
palette->data[i * 2] = 0xff;
palette->data[i * 2 + 1] = 0x7f;
}
}
/* Randomize RAM */
u32 random_seed = init->random_seed;
e->state.random_seed = random_seed;
randomize_buffer(&random_seed, e->state.ext_ram.data, EXT_RAM_MAX_SIZE);
randomize_buffer(&random_seed, e->state.wram.data, WORK_RAM_SIZE);
randomize_buffer(&random_seed, e->state.hram, HIGH_RAM_SIZE);
e->state.cpu_tick = CPU_TICK;
calculate_next_ppu_intr(e);
return OK;
ON_ERROR_RETURN;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
movq 0x30(%rdi), %rax
movq %rsp, %rcx
movq %rax, 0x20(%rsp)
movq %rax, (%rcx)
leaq 0x38(%rdi), %r12
xorl %esi, %esi
pushq $0x1
popq %rbp
movq %r12, 0x18(%rsp)
xorl %r14d, %r14d
cmpq $0x100, %r14 # imm = 0x100
je 0x8252b
leaq 0x8000(%rsi), %r13
cmpq 0x30(%rbx), %r13
ja 0x8252b
movq %r15, %rdi
movq %r12, %rdx
movl %ebp, %ecx
movq %rsp, %r8
callq 0x8cff6
testl %eax, %eax
jne 0x8251f
movl 0x20(%r12), %eax
shlq $0x4, %rax
leaq 0x3470d(%rip), %rcx # 0xb6c20
cmpl $0x5, (%rax,%rcx)
je 0x82565
incl 0x3038(%rbx)
incq %r14
addq $0x30, %r12
movq %r13, %rsi
jmp 0x824d9
cmpl $0x0, 0x3038(%rbx)
jne 0x82562
movq %rsp, %r8
movq %r15, %rdi
xorl %esi, %esi
movq 0x18(%rsp), %rdx
xorl %ecx, %ecx
callq 0x8cff6
movl 0x3038(%rbx), %ecx
testl %eax, %eax
jne 0x8255a
incl %ecx
movl %ecx, 0x3038(%rbx)
testl %ecx, %ecx
je 0x82a2b
xorl %r14d, %r14d
movq (%rsp), %rsi
cmpq 0x20(%rsp), %rsi
jbe 0x8259d
movq %r15, %rdi
callq 0x818e8
movl 0x3038(%rbx), %eax
imulq $0x30, %rax, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x8259d
movq 0x28(%rbx), %rdx
addq 0x38(%rbx,%rcx), %rdx
movq %rdx, 0x40(%rbx,%rcx)
addq $0x30, %rcx
jmp 0x82584
movzbl %r14b, %esi
movq %rbx, %rdi
callq 0x84862
movq 0x3040(%rbx), %r13
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movb $0x0, 0x10(%r15)
movl $0x134, %r12d # imm = 0x134
addq 0x8(%r13), %r12
xorl %ebp, %ebp
pushq $0x10
popq %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x242d0
movl %eax, %ecx
subl %r12d, %ecx
testq %rax, %rax
pushq $0x10
popq %rax
cmovnel %ecx, %eax
movslq %eax, %r14
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x24070
testl %r14d, %r14d
cmovlel %ebp, %r14d
cmpq %rbp, %r14
je 0x82612
cmpb $0x1f, (%rsp,%rbp)
jg 0x8260d
movb $0x20, (%rsp,%rbp)
incq %rbp
jmp 0x825fe
leaq 0x362ce(%rip), %rdi # 0xb88e7
movq %rsp, %rsi
xorl %eax, %eax
callq 0x24060
movl 0x18(%r13), %eax
leaq 0x35f03(%rip), %r15 # 0xb8531
movq %r15, %rsi
cmpq $0xc0, %rax
ja 0x82644
leaq 0x596e0(%rip), %rcx # 0xdbd20
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
cmoveq %r15, %rsi
leaq 0x362a2(%rip), %rdi # 0xb88f4
xorl %eax, %eax
callq 0x24060
movl 0x1c(%r13), %eax
movq %r15, %rsi
cmpq $0x3, %rax
ja 0x82671
leaq 0x59cc3(%rip), %rcx # 0xdc330
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
cmoveq %r15, %rsi
leaq 0x36283(%rip), %rdi # 0xb8902
xorl %eax, %eax
callq 0x24060
movl 0x20(%r13), %eax
movq %r15, %rsi
cmpq $0xff, %rax
ja 0x826a0
leaq 0x59cb4(%rip), %rcx # 0xdc350
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
cmoveq %r15, %rsi
leaq 0x36262(%rip), %rdi # 0xb8910
xorl %eax, %eax
callq 0x24060
movl 0x24(%r13), %eax
movq %r15, %rsi
cmpq $0x8, %rax
ja 0x826cd
leaq 0x5a487(%rip), %rcx # 0xdcb50
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
cmoveq %r15, %rsi
leaq 0x36244(%rip), %rdi # 0xb891f
xorl %eax, %eax
callq 0x24060
movl 0x28(%r13), %ecx
movq %r15, %rax
cmpq $0x5, %rcx
ja 0x826fa
leaq 0x5a4aa(%rip), %rax # 0xdcba0
movq (%rax,%rcx,8), %rax
testq %rax, %rax
cmovneq %rax, %r15
leaq 0x36225(%rip), %rdi # 0xb892d
xorl %r14d, %r14d
movq %r15, %rsi
xorl %eax, %eax
callq 0x24060
movq 0x8(%r13), %rax
movzbl 0x14d(%rax), %esi
xorl %ecx, %ecx
movq 0x28(%rsp), %r15
cmpq $0x19, %r14
je 0x8273e
movb 0x134(%rax,%r14), %dl
notb %dl
addb %dl, %cl
incq %r14
jmp 0x82727
xorl %eax, %eax
cmpb %sil, %cl
setne %al
leaq 0x5a483(%rip), %rcx # 0xdcbd0
movq (%rcx,%rax,8), %rax
testq %rax, %rax
leaq 0x35dd6(%rip), %rdx # 0xb8531
cmovneq %rax, %rdx
leaq 0x361d9(%rip), %rdi # 0xb893f
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x24060
movabsq $0x400000000000, %rax # imm = 0x400000000000
movq %rax, 0x3070(%rbx)
movl 0x20(%r15), %ecx
testl %ecx, %ecx
je 0x82795
andl $0x0, 0x33c10(%rbx)
xorl %eax, %eax
xorl %ebp, %ebp
jmp 0x827d0
movq 0x3040(%rbx), %rax
movl 0x18(%rax), %edx
andl $-0x41, %edx
xorl %eax, %eax
cmpl $0x80, %edx
sete %al
movl %eax, 0x33c10(%rbx)
testl %ecx, %ecx
jne 0x827d0
cmpl $0x80, %edx
je 0x827d0
movq 0x3040(%rbx), %rcx
xorl %ebp, %ebp
cmpl $0x3, 0x1c(%rcx)
sete %bpl
movl %ebp, 0x33c14(%rbx)
movaps 0x32523(%rip), %xmm0 # 0xb4d00
movups %xmm0, 0x30b4(%rbx)
andb $0x1, %al
shlb $0x4, %al
incb %al
movb %al, 0x30a8(%rbx)
movabsq $-0x1feb2ff27ffed, %rax # imm = 0xFFFE014D00D80013
movq %rax, 0x30aa(%rbx)
movw $0x100, 0x30b2(%rbx) # imm = 0x100
andl $0x0, 0x2f0dc(%rbx)
movw $0xac00, 0x33678(%rbx) # imm = 0xAC00
orq $-0x1, 0x33c08(%rbx)
orq $-0x1, 0x33638(%rbx)
orq $-0x1, 0x33668(%rbx)
movw $0x1000, 0x2f0d8(%rbx) # imm = 0x1000
pushq $0x16
popq %rsi
movq %rbx, %rdi
movl $0xf1, %edx
callq 0x82aa5
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movl $0x80, %edx
callq 0x82aa5
pushq $0x2
popq %rsi
movq %rbx, %rdi
movl $0xf3, %edx
callq 0x82aa5
pushq $0x4
popq %rsi
movq %rbx, %rdi
movl $0x80, %edx
callq 0x82aa5
pushq $0x14
popq %rsi
pushq $0x77
popq %rdx
movq %rbx, %rdi
callq 0x82aa5
pushq $0x15
popq %rsi
movq %rbx, %rdi
movl $0xf3, %edx
callq 0x82aa5
movl $0x1, 0x33820(%rbx)
movaps 0x324e3(%rip), %xmm0 # 0xb4d90
movups %xmm0, 0x336cd(%rbx)
movb $0x0, 0x33731(%rbx)
pushq $0x40
popq %rsi
movq %rbx, %rdi
movl $0x91, %edx
callq 0x830fb
pushq $0x42
popq %rsi
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x830fb
pushq $0x43
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x830fb
pushq $0x45
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x830fb
pushq $0x47
popq %rsi
movq %rbx, %rdi
movl $0xfc, %edx
callq 0x830fb
pushq $0x48
popq %rsi
movq %rbx, %rdi
movl $0xff, %edx
callq 0x830fb
pushq $0x49
popq %rsi
movq %rbx, %rdi
movl $0xff, %edx
callq 0x830fb
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x830fb
movq %rbx, %rdi
movl $0xff, %esi
xorl %edx, %edx
callq 0x830fb
movb $-0x1, 0x33b6c(%rbx)
movl 0x1c(%r15), %esi
movq %rbx, %rdi
callq 0x844aa
movl 0x24(%r15), %eax
movl %eax, 0x824f8(%rbx)
leaq 0x81(%rbx), %rax
movl $0x338c4, %ecx # imm = 0x338C4
cmpl $0x2, %r14d
je 0x829b6
testl %r14d, %r14d
movl $0x3398c, %edx # imm = 0x3398C
cmoveq %rcx, %rdx
leaq (%rbx,%rdx), %rsi
addq %rax, %rdx
xorl %edi, %edi
cmpq $0x20, %rdi
je 0x829b1
movl %edi, %r8d
shrl $0x2, %r8d
shlq $0x4, %r8
addq %rsi, %r8
movl %edi, %r9d
andl $0x3, %r9d
orl $-0x1, (%r8,%r9,4)
movw $0x7fff, -0x1(%rdx,%rdi,2) # imm = 0x7FFF
incq %rdi
jmp 0x82985
incl %r14d
jmp 0x8296a
leaq 0x270d8(%rbx), %r14
movl 0x18(%r15), %eax
leaq 0x34(%rsp), %r15
movl %eax, (%r15)
movl %eax, 0x3064(%rbx)
leaq 0x70c8(%rbx), %rsi
movq %r15, %rdi
movl $0x20000, %edx # imm = 0x20000
callq 0x8453f
movq %r15, %rdi
movq %r14, %rsi
movl $0x8000, %edx # imm = 0x8000
callq 0x8453f
leaq 0x33b78(%rbx), %rsi
pushq $0x7f
popq %rdx
movq %r15, %rdi
callq 0x8453f
movq $0x4, 0x33c00(%rbx)
movq %rbx, %rdi
callq 0x84576
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5a5ae(%rip), %rbx # 0xdcfe0
movq (%rbx), %rdi
leaq 0x321e8(%rip), %rsi # 0xb4c24
leaq 0x35221(%rip), %rdx # 0xb7c64
movl $0x4a8, %ecx # imm = 0x4A8
xorl %eax, %eax
callq 0x24160
movq (%rbx), %rcx
leaq 0x35e66(%rip), %rdi # 0xb88bf
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x24670
jmp 0x82a1a
| /binji[P]binjgb/src/emulator.c |
write_apu | static void write_apu(Emulator* e, MaskedAddress addr, u8 value) {
if (e->config.log_apu_writes || !APU.initialized) {
if (e->apu_log.write_count < MAX_APU_LOG_FRAME_WRITES) {
ApuWrite* write = &e->apu_log.writes[e->apu_log.write_count++];
write->addr = addr;
write->value = value;
}
}
if (!APU.enabled) {
if (!IS_CGB && (addr == APU_NR11_ADDR || addr == APU_NR21_ADDR ||
addr == APU_NR31_ADDR || addr == APU_NR41_ADDR)) {
/* DMG allows writes to the length counters when power is disabled. */
} else if (addr == APU_NR52_ADDR) {
/* Always can write to NR52; it's necessary to re-enable power to APU. */
} else {
/* Ignore all other writes. */
HOOK(write_apu_disabled_asb, addr, get_apu_reg_string(addr), value);
return;
}
}
if (APU.initialized) {
apu_synchronize(e);
}
HOOK(write_apu_asb, addr, get_apu_reg_string(addr), value);
switch (addr) {
case APU_NR10_ADDR: {
SweepDirection old_direction = SWEEP.direction;
SWEEP.period = UNPACK(value, NR10_SWEEP_PERIOD);
SWEEP.direction = UNPACK(value, NR10_SWEEP_DIRECTION);
SWEEP.shift = UNPACK(value, NR10_SWEEP_SHIFT);
if (old_direction == SWEEP_DIRECTION_SUBTRACTION &&
SWEEP.direction == SWEEP_DIRECTION_ADDITION &&
SWEEP.calculated_subtract) {
CHANNEL1.status = FALSE;
}
break;
}
case APU_NR11_ADDR:
write_nrx1_reg(e, &CHANNEL1, addr, value);
break;
case APU_NR12_ADDR:
write_nrx2_reg(e, &CHANNEL1, addr, value);
break;
case APU_NR13_ADDR:
write_nrx3_reg(e, &CHANNEL1, value);
write_square_wave_period(e, &CHANNEL1, &CHANNEL1.square_wave);
break;
case APU_NR14_ADDR: {
Bool trigger = write_nrx4_reg(e, &CHANNEL1, addr, value, NRX1_MAX_LENGTH);
write_square_wave_period(e, &CHANNEL1, &CHANNEL1.square_wave);
if (trigger) {
trigger_nrx4_envelope(e, &CHANNEL1.envelope, addr);
trigger_nr14_reg(e, &CHANNEL1);
CHANNEL1.square_wave.ticks = CHANNEL1.square_wave.period;
}
break;
}
case APU_NR21_ADDR:
write_nrx1_reg(e, &CHANNEL2, addr, value);
break;
case APU_NR22_ADDR:
write_nrx2_reg(e, &CHANNEL2, addr, value);
break;
case APU_NR23_ADDR:
write_nrx3_reg(e, &CHANNEL2, value);
write_square_wave_period(e, &CHANNEL2, &CHANNEL2.square_wave);
break;
case APU_NR24_ADDR: {
Bool trigger = write_nrx4_reg(e, &CHANNEL2, addr, value, NRX1_MAX_LENGTH);
write_square_wave_period(e, &CHANNEL2, &CHANNEL2.square_wave);
if (trigger) {
trigger_nrx4_envelope(e, &CHANNEL2.envelope, addr);
CHANNEL2.square_wave.ticks = CHANNEL2.square_wave.period;
}
break;
}
case APU_NR30_ADDR:
CHANNEL3.dac_enabled = UNPACK(value, NR30_DAC_ENABLED);
if (!CHANNEL3.dac_enabled) {
CHANNEL3.status = FALSE;
WAVE.playing = FALSE;
}
break;
case APU_NR31_ADDR:
CHANNEL3.length = NR31_MAX_LENGTH - value;
break;
case APU_NR32_ADDR:
WAVE.volume = UNPACK(value, NR32_SELECT_WAVE_VOLUME);
assert(WAVE.volume < WAVE_VOLUME_COUNT);
WAVE.volume_shift = s_wave_volume_shift[WAVE.volume];
break;
case APU_NR33_ADDR:
write_nrx3_reg(e, &CHANNEL3, value);
write_wave_period(e, &CHANNEL3);
break;
case APU_NR34_ADDR: {
Bool trigger = write_nrx4_reg(e, &CHANNEL3, addr, value, NR31_MAX_LENGTH);
write_wave_period(e, &CHANNEL3);
if (trigger) {
if (!IS_CGB && WAVE.playing) {
/* Triggering the wave channel while it is already playing will
* corrupt the wave RAM on DMG. */
if (WAVE.ticks == WAVE_TRIGGER_CORRUPTION_OFFSET_TICKS) {
assert(WAVE.position < 32);
u8 position = (WAVE.position + 1) & 31;
u8 byte = WAVE.ram[position >> 1];
switch (position >> 3) {
case 0:
WAVE.ram[0] = byte;
break;
case 1:
case 2:
case 3:
memcpy(&WAVE.ram[0], &WAVE.ram[(position >> 1) & 12], 4);
break;
}
HOOK(corrupt_wave_ram_i, position);
}
}
WAVE.position = 0;
WAVE.ticks = WAVE.period + WAVE_TRIGGER_DELAY_TICKS;
WAVE.playing = TRUE;
}
break;
}
case APU_NR41_ADDR:
write_nrx1_reg(e, &CHANNEL4, addr, value);
break;
case APU_NR42_ADDR:
write_nrx2_reg(e, &CHANNEL4, addr, value);
break;
case APU_NR43_ADDR: {
NOISE.clock_shift = UNPACK(value, NR43_CLOCK_SHIFT);
NOISE.lfsr_width = UNPACK(value, NR43_LFSR_WIDTH);
NOISE.divisor = UNPACK(value, NR43_DIVISOR);
write_noise_period(e);
break;
}
case APU_NR44_ADDR: {
Bool trigger = write_nrx4_reg(e, &CHANNEL4, addr, value, NRX1_MAX_LENGTH);
if (trigger) {
write_noise_period(e);
trigger_nrx4_envelope(e, &CHANNEL4.envelope, addr);
NOISE.lfsr = 0x7fff;
NOISE.sample = 1;
NOISE.ticks = NOISE.period;
}
break;
}
case APU_NR50_ADDR:
APU.so_output[VIN][1] = UNPACK(value, NR50_VIN_SO2);
APU.so_volume[1] = UNPACK(value, NR50_SO2_VOLUME);
APU.so_output[VIN][0] = UNPACK(value, NR50_VIN_SO1);
APU.so_volume[0] = UNPACK(value, NR50_SO1_VOLUME);
break;
case APU_NR51_ADDR:
APU.so_output[SOUND4][1] = UNPACK(value, NR51_SOUND4_SO2);
APU.so_output[SOUND3][1] = UNPACK(value, NR51_SOUND3_SO2);
APU.so_output[SOUND2][1] = UNPACK(value, NR51_SOUND2_SO2);
APU.so_output[SOUND1][1] = UNPACK(value, NR51_SOUND1_SO2);
APU.so_output[SOUND4][0] = UNPACK(value, NR51_SOUND4_SO1);
APU.so_output[SOUND3][0] = UNPACK(value, NR51_SOUND3_SO1);
APU.so_output[SOUND2][0] = UNPACK(value, NR51_SOUND2_SO1);
APU.so_output[SOUND1][0] = UNPACK(value, NR51_SOUND1_SO1);
break;
case APU_NR52_ADDR: {
Bool was_enabled = APU.enabled;
Bool is_enabled = UNPACK(value, NR52_ALL_SOUND_ENABLED);
if (was_enabled && !is_enabled) {
HOOK0(apu_power_down_v);
int i;
for (i = 0; i < APU_REG_COUNT; ++i) {
if (i != APU_NR52_ADDR) {
write_apu(e, i, 0);
}
}
} else if (!was_enabled && is_enabled) {
HOOK0(apu_power_up_v);
APU.frame = 7;
}
APU.enabled = is_enabled;
break;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
je 0x82ae7
movq 0x82d00(%rbx), %rax
cmpq $0x3ff, %rax # imm = 0x3FF
ja 0x82af0
leaq 0x1(%rax), %rcx
movq %rcx, 0x82d00(%rbx)
movb %r15b, 0x82500(%rbx,%rax,2)
movb %bpl, 0x82501(%rbx,%rax,2)
jmp 0x82af0
cmpl $0x0, 0x33820(%rbx)
je 0x82abb
cmpl $0x0, 0x336ac(%rbx)
movzwl %r15w, %r12d
movzbl %bpl, %r14d
je 0x82bbf
cmpl $0x0, 0x33820(%rbx)
je 0x82b16
movq %rbx, %rdi
callq 0x81f1b
leaq 0x35a14(%rip), %rcx # 0xb8531
movq %rcx, %rax
cmpw $0x16, %r15w
ja 0x82b32
leaq 0x5a0b2(%rip), %rax # 0xdcbe0
movq (%rax,%r12,8), %rax
testq %rax, %rax
cmovneq %rax, %rcx
movq %rbx, %rdi
movl %r12d, %edx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x8d1bd
cmpw $0x16, %r15w
ja 0x83033
leaq 0x32275(%rip), %rax # 0xb4dd0
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x336b4(%rbx), %eax
movl %ebp, %ecx
shrb $0x4, %cl
andb $0x7, %cl
movb %cl, 0x336b0(%rbx)
movl %r14d, %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
movl %ecx, 0x336b4(%rbx)
andb $0x7, %bpl
movb %bpl, 0x336b8(%rbx)
btl $0x3, %r14d
jb 0x83033
cmpl $0x1, %eax
jne 0x83033
cmpl $0x0, 0x336c4(%rbx)
je 0x83033
andl $0x0, 0x3374c(%rbx)
jmp 0x83033
cmpl $0x0, 0x33c10(%rbx)
je 0x82c0e
cmpw $0x16, %r15w
je 0x82b05
leaq 0x35957(%rip), %rcx # 0xb8531
movq %rcx, %rax
cmpw $0x16, %r15w
ja 0x82bef
leaq 0x59ff5(%rip), %rax # 0xdcbe0
movq (%rax,%r12,8), %rax
testq %rax, %rax
cmovneq %rax, %rcx
movq %rbx, %rdi
movl %r12d, %edx
movl %r14d, %r8d
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d0f0
cmpw $0x16, %r15w
ja 0x82bd3
movl $0x410842, %eax # imm = 0x410842
btl %r12d, %eax
jb 0x82b05
jmp 0x82bd3
movl %r14d, %eax
shrl $0x7, %eax
movl %eax, 0x336a8(%rbx)
movl %ebp, %eax
shrb $0x4, %al
andb $0x7, %al
movb %al, 0x33681(%rbx)
shrl $0x3, %r14d
andl $0x1, %r14d
movl %r14d, 0x336a4(%rbx)
andb $0x7, %bpl
movb %bpl, 0x33680(%rbx)
jmp 0x83033
leaq 0x33794(%rbx), %r15
pushq $0xe
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %ecx
movl $0x100, %r8d # imm = 0x100
callq 0x8d3ee
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8d555
testl %ebp, %ebp
je 0x83033
cmpl $0x0, 0x33c10(%rbx)
je 0x83063
movb $0x0, 0x336f0(%rbx)
movl 0x336ec(%rbx), %eax
addl $0x6, %eax
movl %eax, 0x336f4(%rbx)
movl $0x1, 0x336f8(%rbx)
jmp 0x83033
movl $0x100, %eax # imm = 0x100
subl %r14d, %eax
movw %ax, 0x337c2(%rbx)
jmp 0x83033
leaq 0x33794(%rbx), %rsi
movb %bpl, 0x337c0(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d555
movl %r14d, %eax
shrl $0x7, %eax
movl %eax, 0x336a0(%rbx)
movl %r14d, %eax
shrl $0x6, %eax
andl $0x1, %eax
movl %eax, 0x33698(%rbx)
movl %r14d, %eax
shrl $0x5, %eax
andl $0x1, %eax
movl %eax, 0x33690(%rbx)
movl %r14d, %eax
shrl $0x4, %eax
andl $0x1, %eax
movl %eax, 0x33688(%rbx)
movl %r14d, %eax
shrl $0x3, %eax
andl $0x1, %eax
movl %eax, 0x3369c(%rbx)
movl %r14d, %eax
shrl $0x2, %eax
andl $0x1, %eax
movl %eax, 0x33694(%rbx)
movl %r14d, %eax
shrl %eax
andl $0x1, %eax
movl %eax, 0x3368c(%rbx)
andl $0x1, %r14d
movl %r14d, 0x33684(%rbx)
jmp 0x83033
leaq 0x33714(%rbx), %rsi
pushq $0x2
jmp 0x82df1
leaq 0x33754(%rbx), %rsi
pushq $0x6
jmp 0x82dd4
shrl $0x5, %r14d
andl $0x3, %r14d
movl %r14d, 0x336c8(%rbx)
leaq 0x34eca(%rip), %rax # 0xb7c60
movb (%r14,%rax), %al
movb %al, 0x336cc(%rbx)
jmp 0x83033
leaq 0x33714(%rbx), %rsi
pushq $0x1
jmp 0x82dd4
leaq 0x33754(%rbx), %rsi
pushq $0x7
jmp 0x82df1
leaq 0x33754(%rbx), %rdx
movb %bpl, 0x33780(%rbx)
jmp 0x82e13
leaq 0x337d4(%rbx), %rsi
pushq $0x10
popq %rdx
movq %rbx, %rdi
movl %r14d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d28a
leaq 0x337d4(%rbx), %rsi
pushq $0x11
popq %rdx
movq %rbx, %rdi
movl %r14d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d2be
leaq 0x33714(%rbx), %rdx
movb %bpl, 0x33740(%rbx)
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ccf3
leaq 0x33714(%rbx), %r15
pushq $0x4
popq %rdx
pushq $0x40
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %ecx
callq 0x8d3ee
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x8ccf3
testl %ebp, %ebp
je 0x83033
leaq 0x33728(%rbx), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x8d4f3
movl 0x336b0(%rbx), %eax
testb %al, %al
movb 0x336b8(%rbx), %cl
pushq $0x8
popq %rdx
cmovnel %eax, %edx
xorl %esi, %esi
movl %ecx, %edi
orb %al, %dil
setne %sil
movl %esi, 0x336c0(%rbx)
movzwl 0x33740(%rbx), %eax
movw %ax, 0x336ba(%rbx)
movb %dl, 0x336bc(%rbx)
andl $0x0, 0x336c4(%rbx)
testb %cl, %cl
je 0x82ec9
movq %rbx, %rdi
callq 0x8cb23
cmpw $0x7ff, %ax # imm = 0x7FF
ja 0x830c6
movzwl 0x336ba(%rbx), %eax
movzwl %ax, %edx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8e102
movl 0x3371c(%rbx), %eax
movl %eax, 0x33724(%rbx)
jmp 0x83033
shrl $0x7, %r14d
movl %r14d, 0x337c8(%rbx)
testb %bpl, %bpl
js 0x83033
andl $0x0, 0x337cc(%rbx)
andl $0x0, 0x336f8(%rbx)
jmp 0x83033
leaq 0x33754(%rbx), %r15
pushq $0x9
popq %rdx
pushq $0x40
popq %r8
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %ecx
callq 0x8d3ee
movl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x8ccf3
testl %ebp, %ebp
je 0x83033
leaq 0x33768(%rbx), %rsi
pushq $0x9
popq %rdx
movq %rbx, %rdi
callq 0x8d4f3
movl 0x3375c(%rbx), %eax
movl %eax, 0x33764(%rbx)
jmp 0x83033
leaq 0x337d4(%rbx), %rsi
pushq $0x13
popq %rdx
pushq $0x40
popq %r8
movq %rbx, %rdi
movl %r14d, %ecx
callq 0x8d3ee
testl %eax, %eax
je 0x83033
movq %rbx, %rdi
callq 0x8d646
leaq 0x337e8(%rbx), %rsi
pushq $0x13
popq %rdx
movq %rbx, %rdi
callq 0x8d4f3
movw $0x7fff, 0x3370a(%rbx) # imm = 0x7FFF
movb $0x1, 0x33709(%rbx)
movl 0x3370c(%rbx), %eax
movl %eax, 0x33710(%rbx)
jmp 0x83033
movl %ebp, %eax
shrb $0x4, %al
movb %al, 0x33700(%rbx)
shrl $0x3, %r14d
andl $0x1, %r14d
movl %r14d, 0x33704(%rbx)
andb $0x7, %bpl
movb %bpl, 0x33708(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8d646
movl 0x336ac(%rbx), %eax
shrl $0x7, %r14d
testl %eax, %eax
sete %cl
testb %bpl, %bpl
sets %dl
orb %cl, %dl
je 0x8303c
testb %bpl, %bpl
setns %cl
testl %eax, %eax
setne %al
orb %cl, %al
jne 0x8302c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d766
movb $0x7, 0x33814(%rbx)
movl %r14d, 0x336ac(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d699
cmpl $0x16, %ebp
je 0x8305f
cmpl $0x17, %ebp
je 0x8302c
movzwl %bp, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x82aa5
incl %ebp
jmp 0x83048
cmpl $0x0, 0x336f8(%rbx)
je 0x82c9e
cmpl $0x2, 0x336f4(%rbx)
jne 0x82c9e
movzbl 0x336f0(%rbx), %edx
cmpq $0x20, %rdx
jae 0x830dc
incl %edx
andl $0x1f, %edx
movl %edx, %eax
shrl %eax
cmpb $0x7, %dl
ja 0x830a7
movb 0x336cd(%rbx,%rax), %al
movb %al, 0x336cd(%rbx)
jmp 0x830b7
andl $-0x4, %eax
movl 0x336cd(%rbx,%rax), %eax
movl %eax, 0x336cd(%rbx)
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8d579
jmp 0x82c9e
andl $0x0, 0x3374c(%rbx)
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8e035
jmp 0x82ed6
leaq 0x35c2e(%rip), %rdi # 0xb8d11
leaq 0x34b7a(%rip), %rsi # 0xb7c64
leaq 0x35bf2(%rip), %rcx # 0xb8ce3
movl $0xc53, %edx # imm = 0xC53
callq 0x24110
| /binji[P]binjgb/src/emulator.c |
randomize_buffer | static void randomize_buffer(u32* seed, u8* buffer, u32 size) {
while (size >= sizeof(u32)) {
u32 x = random_u32(seed);
memcpy(buffer, &x, sizeof(x));
buffer += sizeof(u32);
size -= sizeof(u32);
}
if (size > 0) {
u32 x = random_u32(seed);
switch (size) {
case 3: *buffer++ = x & 0xff; x >>= 8; break;
case 2: *buffer++ = x & 0xff; x >>= 8; break;
case 1: *buffer++ = x & 0xff; x >>= 8; break;
}
}
} | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x4, %ebp
jb 0x84563
movq %r14, %rdi
callq 0x8ea9f
movl %eax, (%rbx)
addq $0x4, %rbx
addl $-0x4, %ebp
jmp 0x8454b
testl %ebp, %ebp
je 0x84571
movq %r14, %rdi
callq 0x8ea9f
movb %al, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
| /binji[P]binjgb/src/emulator.c |
calculate_next_ppu_intr | static void calculate_next_ppu_intr(Emulator* e) {
if (LCDC.display) {
/* TODO: Looser bounds on sync points. This syncs at every state
* transition, even though we often won't need to sync that often. */
PPU.next_intr_ticks = PPU.sync_ticks + PPU.state_ticks;
} else {
PPU.next_intr_ticks = INVALID_TICKS;
}
calculate_next_intr(e);
} | cmpl $0x0, 0x33838(%rdi)
je 0x8458e
movl 0x33a68(%rdi), %eax
addq 0x33828(%rdi), %rax
jmp 0x84591
pushq $-0x1
popq %rax
movq %rax, 0x33830(%rdi)
movq 0x33638(%rdi), %rcx
movq 0x33668(%rdi), %rdx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movq %rdx, 0x33c08(%rdi)
retq
| /binji[P]binjgb/src/emulator.c |
emulator_read_state | Result emulator_read_state(Emulator* e, const FileData* file_data) {
CHECK_MSG(file_data->size == sizeof(EmulatorState),
"save state file is wrong size: %ld, expected %ld.\n",
(long)file_data->size, (long)sizeof(EmulatorState));
EmulatorState* new_state = (EmulatorState*)file_data->data;
CHECK_MSG(new_state->header == SAVE_STATE_HEADER,
"header mismatch: %u, expected %u.\n", new_state->header,
SAVE_STATE_HEADER);
memcpy(&e->state, new_state, sizeof(EmulatorState));
set_cart_info(e, e->state.cart_info_index);
if (IS_SGB) {
emulator_set_bw_palette(e, PALETTE_TYPE_OBP0, &SGB.screen_pal[0]);
emulator_set_bw_palette(e, PALETTE_TYPE_OBP1, &SGB.screen_pal[0]);
}
update_bw_palette_rgba(e, PALETTE_TYPE_BGP);
update_bw_palette_rgba(e, PALETTE_TYPE_OBP0);
update_bw_palette_rgba(e, PALETTE_TYPE_OBP1);
return OK;
ON_ERROR_RETURN;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpq $0x30bc0, 0x8(%rsi) # imm = 0x30BC0
jne 0x847dd
movq (%r14), %r14
cmpl $0x6b57a7e2, (%r14) # imm = 0x6B57A7E2
jne 0x8481d
movq %rdi, %rbx
addq $0x3060, %rdi # imm = 0x3060
movl $0x30bc0, %edx # imm = 0x30BC0
movq %r14, %rsi
callq 0x24070
movzbl 0x3068(%rbx), %esi
movq %rbx, %rdi
callq 0x84862
cmpl $0x0, 0x33c14(%rbx)
je 0x847b4
movups 0x33464(%rbx), %xmm0
movups %xmm0, 0x82468(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x84657
movups 0x33464(%rbx), %xmm0
movups %xmm0, 0x82478(%rbx)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x84657
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x84657
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x84657
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x84657
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x587fc(%rip), %rbx # 0xdcfe0
movq (%rbx), %rdi
leaq 0x30436(%rip), %rsi # 0xb4c24
leaq 0x3346f(%rip), %rdx # 0xb7c64
movl $0x1345, %ecx # imm = 0x1345
xorl %eax, %eax
callq 0x24160
movq (%rbx), %rdi
movq 0x8(%r14), %rdx
leaq 0x334c6(%rip), %rsi # 0xb7cd5
movl $0x30bc0, %ecx # imm = 0x30BC0
xorl %eax, %eax
callq 0x24160
jmp 0x8485a
movq 0x587bc(%rip), %rbx # 0xdcfe0
movq (%rbx), %rdi
leaq 0x303f6(%rip), %rsi # 0xb4c24
leaq 0x3342f(%rip), %rdx # 0xb7c64
movl $0x1349, %ecx # imm = 0x1349
xorl %eax, %eax
callq 0x24160
movq (%rbx), %rdi
movl (%r14), %edx
leaq 0x334ba(%rip), %rsi # 0xb7d08
movl $0x6b57a7e2, %ecx # imm = 0x6B57A7E2
xorl %eax, %eax
callq 0x24160
pushq $0x1
popq %rbp
jmp 0x847d6
| /binji[P]binjgb/src/emulator.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.