name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
ear::throw_if_not_implemented::operator()(ear::PolarObjectDivergence const&) const
|
void operator()(const PolarObjectDivergence& divergence) const {
if (divergence.divergence != 0.0) throw not_implemented("divergence");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4aebb
jp 0x4aebb
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6cc64(%rip), %rsi # 0xb7b3c
leaq 0x6cc67(%rip), %rdx # 0xb7b46
leaq 0x8(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4aada
xorl %ebp, %ebp
leaq 0xc022e(%rip), %rsi # 0x10b130
movq 0xc506f(%rip), %rdx # 0x10ff78
movq %rbx, %rdi
callq 0x14a60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4af2b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x4af35
jmp 0x4af3d
movq %rax, %r14
movq %rbx, %rdi
callq 0x14460
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/object_based/gain_calculator_objects.cpp
|
ear::throw_if_not_implemented::operator()(ear::CartesianObjectDivergence const&) const
|
void operator()(const CartesianObjectDivergence& divergence) const {
if (divergence.divergence != 0.0) throw not_implemented("divergence");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4af6b
jp 0x4af6b
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6cbb4(%rip), %rsi # 0xb7b3c
leaq 0x6cbb7(%rip), %rdx # 0xb7b46
leaq 0x8(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4aada
xorl %ebp, %ebp
leaq 0xc017e(%rip), %rsi # 0x10b130
movq 0xc4fbf(%rip), %rdx # 0x10ff78
movq %rbx, %rdi
callq 0x14a60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4afdb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x4afe5
jmp 0x4afed
movq %rax, %r14
movq %rbx, %rdi
callq 0x14460
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/object_based/gain_calculator_objects.cpp
|
ear::PolarExtentCoreSimd<xsimd::avx512bw>::run(ear::PolarExtentCoreContext&) const
|
void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i += batch::size) {
PositionBatch<batch> pos;
pos.x = batch::load_aligned(ctx.xs + i);
pos.y = batch::load_aligned(ctx.ys + i);
pos.z = batch::load_aligned(ctx.zs + i);
batch weight = ctx.is_circular ? weight_circle(ctx, pos)
: weight_stadium(ctx, pos);
bool all_zeros = xsimd::all(weight == 0.0);
bool all_ones = xsimd::all(weight == 1.0);
if (all_ones) {
// add pre-computed sum for this batch
size_t batch_i = i / batch::size;
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx += batch::size) {
batch gain =
batch::load_aligned(ctx.summed_panning_results +
(batch_i * ctx.num_speakers) + speaker_idx);
extent_float_t *result_ptr = ctx.results + speaker_idx;
xsimd::store_aligned(result_ptr,
batch::load_aligned(result_ptr) + gain);
}
} else if (!all_zeros) {
for (size_t speaker_idx = 0; speaker_idx < ctx.real_num_speakers;
speaker_idx++) {
batch gain = batch::load_aligned(ctx.panning_results +
speaker_idx * ctx.num_points + i);
ctx.results[speaker_idx] += xsimd::reduce_add(gain * weight);
}
}
}
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0x100, %rsp # imm = 0x100
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4b5c5
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x4b77c
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r13d, %r13d
leaq (,%r13,4), %rax
movq 0x18(%rbx), %rcx
addq %rax, %rcx
testb $0x3f, %cl
jne 0x4b78e
vmovaps (%rcx), %zmm1
vmovaps %zmm1, (%rsp)
movq 0x20(%rbx), %rcx
addq %rax, %rcx
testb $0x3f, %cl
jne 0x4b78e
vmovaps (%rcx), %zmm2
vmovaps %zmm2, 0x40(%rsp)
addq 0x28(%rbx), %rax
testb $0x3f, %al
jne 0x4b78e
vmovaps (%rax), %zmm0
vmovaps %zmm0, 0x80(%rsp)
cmpb $0x1, 0x40(%rbx)
jne 0x4b65d
vmulps 0x58(%rbx){1to16}, %zmm0, %zmm0
vfmadd231ps 0x54(%rbx){1to16}, %zmm2, %zmm0 # zmm0 = (zmm2 * mem) + zmm0
vfmadd231ps 0x50(%rbx){1to16}, %zmm1, %zmm0 # zmm0 = (zmm1 * mem) + zmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b952
jmp 0x4b66b
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4b7b0
vcmpneqps 0x6a812(%rip){1to16}, %zmm0, %k0 # 0xb5e88
kortestw %k0, %k0
je 0x4b710
vcmpneqps 0x81035(%rip), %zmm0, %k0 # 0xcc6c0
kortestw %k0, %k0
je 0x4b76b
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4b76b
movq (%rbx), %rcx
movq 0x30(%rbx), %rdx
movq 0x90(%rbx), %rsi
shlq $0x2, %rcx
movq %r12, %rdi
xorl %r8d, %r8d
leal (%rdx,%rdi), %r9d
testb $0x3f, %r9b
jne 0x4b78e
vmulps (%rdx,%rdi), %zmm0, %zmm1
vextractf128 $0x1, %ymm1, %xmm2
vextractf32x4 $0x2, %zmm1, %xmm3
vextractf32x4 $0x3, %zmm1, %xmm4
vaddps %xmm4, %xmm3, %xmm3
vaddps %xmm2, %xmm1, %xmm1
vaddps %xmm3, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vaddss (%rsi,%r8,4), %xmm1, %xmm1
vmovss %xmm1, (%rsi,%r8,4)
incq %r8
addq %rcx, %rdi
cmpq %r8, %rax
jne 0x4b6ba
jmp 0x4b76b
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x4b76b
movq %r13, %rax
shrq $0x4, %rax
xorl %ecx, %ecx
imulq %rax, %rdx
shlq $0x2, %rdx
addq 0x38(%rbx), %rdx
leaq (%rdx,%rcx,4), %rdx
testb $0x3f, %dl
jne 0x4b78e
leaq (,%rcx,4), %rsi
addq 0x90(%rbx), %rsi
testb $0x3f, %sil
jne 0x4b78e
vmovaps (%rdx), %zmm0
vaddps (%rsi), %zmm0, %zmm0
vmovaps %zmm0, (%rsi)
addq $0x10, %rcx
movq 0x8(%rbx), %rdx
cmpq %rdx, %rcx
jb 0x4b722
addq $0x10, %r13
addq $0x40, %r12
cmpq (%rbx), %r13
jb 0x4b5d8
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0x80faa(%rip), %rdi # 0xcc73f
leaq 0x8100a(%rip), %rsi # 0xcc7a6
leaq 0x81077(%rip), %rcx # 0xcc81a
movl $0x268, %edx # imm = 0x268
vzeroupper
callq 0x143c0
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::avx512bw>::weight_stadium(ear::PolarExtentCoreContext&, ear::PositionBatch<xsimd::batch<float, xsimd::avx512bw>> const&) const
|
batch weight_stadium(PolarExtentCoreContext &ctx,
const PositionBatch<batch> &position) const {
PositionBatch<batch> position_t = position.transform(ctx.flippedBasis);
PositionBatch<batch> position_t_right = position_t;
position_t_right.x = xsimd::abs(position_t.x);
auto circle_test_dot =
xsimd::fma(position_t_right.x, batch{ctx.circle_test[0]},
position_t_right.y * batch{ctx.circle_test[1]});
auto in_straight_line_part = circle_test_dot >= batch{0.0};
// for the straight line part
auto straight_val = weight_from_sin(ctx, xsimd::abs(position_t.z));
// for the circle part
auto circle_dot =
xsimd::fma(position_t_right.x, batch{ctx.right_circle_centre[0]},
position_t_right.y * batch{ctx.right_circle_centre[1]});
auto circle_val = weight_from_cos(ctx, circle_dot);
if (xsimd::all(in_straight_line_part))
return straight_val;
else if (xsimd::none(in_straight_line_part))
return circle_val;
else
return xsimd::select(in_straight_line_part, straight_val, circle_val);
}
|
pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rsi), %rax
movq 0x58(%rsi), %rcx
movq 0x60(%rsi), %rsi
movq 0x68(%rbx), %rdi
shldq $0x20, %rdi, %rax
movq %rdi, %r8
shldq $0x20, %rsi, %r8
shrdq $0x20, %rsi, %rcx
vmovq %rdi, %xmm0
vmovq %rcx, %xmm1
vpbroadcastd %xmm1, %zmm1
vmovddup 0x60(%rbx), %xmm2 # xmm2 = mem[0,0]
vbroadcastss %xmm2, %zmm2
vmovq %r8, %xmm3
vpbroadcastd %xmm3, %zmm3
vmovaps (%rdx), %zmm4
vmovaps 0x40(%rdx), %zmm5
vmovaps 0x80(%rdx), %zmm6
vmulps 0x4c(%rbx){1to16}, %zmm6, %zmm7
vfmadd231ps 0x48(%rbx){1to16}, %zmm5, %zmm7 # zmm7 = (zmm5 * mem) + zmm7
vfmadd231ps 0x44(%rbx){1to16}, %zmm4, %zmm7 # zmm7 = (zmm4 * mem) + zmm7
vmulps 0x58(%rbx){1to16}, %zmm6, %zmm8
vfmadd231ps 0x54(%rbx){1to16}, %zmm5, %zmm8 # zmm8 = (zmm5 * mem) + zmm8
vmulps %zmm3, %zmm6, %zmm3
vfmadd231ps 0x50(%rbx){1to16}, %zmm4, %zmm8 # zmm8 = (zmm4 * mem) + zmm8
vmovups %zmm8, 0xd0(%rsp)
vfmadd231ps %zmm2, %zmm5, %zmm3 # zmm3 = (zmm5 * zmm2) + zmm3
vfmadd231ps %zmm1, %zmm4, %zmm3 # zmm3 = (zmm4 * zmm1) + zmm3
vbroadcastsd 0x80e93(%rip), %zmm1 # 0xcc700
vandps %zmm1, %zmm7, %zmm4
vmovups %zmm4, 0x90(%rsp)
vpbroadcastd %xmm0, %zmm0
vmovq %rax, %xmm2
vpbroadcastd %xmm2, %zmm2
vmulps %zmm2, %zmm8, %zmm2
vfmadd231ps %zmm0, %zmm4, %zmm2 # zmm2 = (zmm4 * zmm0) + zmm2
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm2, 0x10(%rsp)
vcmpleps %zmm2, %zmm0, %k0
kmovw %k0, 0xe(%rsp)
vandps %zmm1, %zmm3, %zmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4ba9c
vmovups %zmm0, 0x50(%rsp)
vmovups 0xd0(%rsp), %zmm0
vmulps 0x74(%rbx){1to16}, %zmm0, %zmm0
vmovups 0x90(%rsp), %zmm1
vfmadd231ps 0x70(%rbx){1to16}, %zmm1, %zmm0 # zmm0 = (zmm1 * mem) + zmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b952
kmovw 0xe(%rsp), %k0
kortestw %k0, %k0
je 0x4b93a
kmovw %k0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
vmovups 0x50(%rsp), %zmm2
je 0x4b940
vxorps %xmm1, %xmm1, %xmm1
vcmpleps 0x10(%rsp), %zmm1, %k1
vmovaps %zmm2, %zmm0 {%k1}
vmovaps %zmm0, %zmm2
vmovaps %zmm2, %zmm0
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r14
retq
nop
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::avx512bw>::weight_from_cos(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::avx512bw>) const
|
inline batch_bool<float, A> ge(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
{
return _mm512_cmp_ps_mask(self, other, _CMP_GE_OQ);
}
|
vcmpgeps 0x78(%rsi){1to16}, %zmm0, %k1
kortestw %k1, %k1
jb 0x4ba8c
vbroadcastss 0x7c(%rsi), %zmm1
vcmpleps %zmm1, %zmm0, %k0
kortestw %k0, %k0
jb 0x4ba97
vbroadcastsd 0x80d7a(%rip), %zmm2 # 0xcc700
vandps %zmm2, %zmm0, %zmm3
vbroadcastss 0x64a32(%rip), %zmm4 # 0xb03c8
vcmpltps %zmm3, %zmm4, %k2
vbroadcastss 0x64a19(%rip), %zmm5 # 0xb03c0
vfmadd213ps %zmm4, %zmm5, %zmm3 # zmm3 = (zmm5 * zmm3) + zmm4
vmovaps %zmm0, %zmm6
vsqrtps %zmm3, %zmm6 {%k2}
vandps %zmm2, %zmm6, %zmm2
vcmpltps %zmm2, %zmm4, %k3
vbroadcastss 0x6a4b8(%rip), %zmm3 # 0xb5e88
vsubps %zmm2, %zmm3, %zmm7
vmulps %zmm2, %zmm2, %zmm8
vmulps %zmm4, %zmm7, %zmm8 {%k3}
vsqrtps %zmm8, %zmm2 {%k3}
vbroadcastss 0x80c96(%rip), %zmm4 # 0xcc688
vfmadd213ps 0x80c90(%rip){1to16}, %zmm8, %zmm4 # zmm4 = (zmm8 * zmm4) + mem
vfmadd213ps 0x80c8a(%rip){1to16}, %zmm8, %zmm4 # zmm4 = (zmm8 * zmm4) + mem
vfmadd213ps 0x80c84(%rip){1to16}, %zmm8, %zmm4 # zmm4 = (zmm8 * zmm4) + mem
vfmadd213ps 0x80c7e(%rip){1to16}, %zmm8, %zmm4 # zmm4 = (zmm8 * zmm4) + mem
vmulps %zmm2, %zmm8, %zmm7
vfmadd213ps %zmm2, %zmm4, %zmm7 # zmm7 = (zmm4 * zmm7) + zmm2
vaddps %zmm7, %zmm7, %zmm2
vbroadcastss 0x80c66(%rip), %zmm4 # 0xcc69c
vsubps %zmm2, %zmm4, %zmm7 {%k3}
vpternlogq $0x78, 0x80cc1(%rip){1to8}, %zmm6, %zmm7 # 0xcc708
vaddps %zmm7, %zmm7, %zmm7 {%k2}
vcmpltps %zmm5, %zmm0, %k3
vbroadcastss 0x80c42(%rip), %zmm2 # 0xcc6a0
vsubps %zmm7, %zmm2, %zmm7 {%k3}
vsubps %zmm7, %zmm4, %zmm2
vmovaps %zmm7, %zmm2 {%k2}
vmulps 0x88(%rsi){1to16}, %zmm2, %zmm2
vcmpnleps %zmm1, %zmm0, %k2
vaddps 0x8c(%rsi){1to16}, %zmm2, %zmm0 {%k2} {z}
vmovaps %zmm3, %zmm0 {%k1}
retq
vbroadcastss 0x6a3f2(%rip), %zmm0 # 0xb5e88
retq
vxorps %xmm0, %xmm0, %xmm0
retq
|
/ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx512f.hpp
|
ear::PolarExtentCoreSimd<xsimd::avx512bw>::weight_from_sin(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::avx512bw>) const
|
inline batch_bool<float, A> le(batch<float, A> const& self, batch<float, A> const& other, requires_arch<avx512f>) noexcept
{
return _mm512_cmp_ps_mask(self, other, _CMP_LE_OQ);
}
|
vcmpleps 0x80(%rsi){1to16}, %zmm0, %k1
kortestw %k1, %k1
jb 0x4bb7e
vbroadcastss 0x84(%rsi), %zmm1
vcmpleps %zmm0, %zmm1, %k0
kortestw %k0, %k0
jb 0x4bb89
vandpd 0x80c30(%rip){1to8}, %zmm0, %zmm2 # 0xcc700
vbroadcastss 0x648ee(%rip), %zmm3 # 0xb03c8
vcmpltps %zmm2, %zmm3, %k2
vbroadcastss 0x6a39d(%rip), %zmm4 # 0xb5e88
vsubps %zmm2, %zmm4, %zmm5
vmulps %zmm2, %zmm2, %zmm6
vmulps %zmm3, %zmm5, %zmm6 {%k2}
vsqrtps %zmm6, %zmm2 {%k2}
vbroadcastss 0x80b7b(%rip), %zmm3 # 0xcc688
vfmadd213ps 0x80b75(%rip){1to16}, %zmm6, %zmm3 # zmm3 = (zmm6 * zmm3) + mem
vfmadd213ps 0x80b6f(%rip){1to16}, %zmm6, %zmm3 # zmm3 = (zmm6 * zmm3) + mem
vfmadd213ps 0x80b69(%rip){1to16}, %zmm6, %zmm3 # zmm3 = (zmm6 * zmm3) + mem
vfmadd213ps 0x80b63(%rip){1to16}, %zmm6, %zmm3 # zmm3 = (zmm6 * zmm3) + mem
vmulps %zmm2, %zmm6, %zmm5
vfmadd213ps %zmm2, %zmm3, %zmm5 # zmm5 = (zmm3 * zmm5) + zmm2
vaddps %zmm5, %zmm5, %zmm2
vbroadcastss 0x80b4b(%rip), %zmm3 # 0xcc69c
vsubps %zmm2, %zmm3, %zmm5 {%k2}
vpternlogq $0x78, 0x80ba6(%rip){1to8}, %zmm0, %zmm5 # 0xcc708
vmulps 0x88(%rsi){1to16}, %zmm5, %zmm2
vcmpnleps %zmm0, %zmm1, %k2
vaddps 0x8c(%rsi){1to16}, %zmm2, %zmm0 {%k2} {z}
vmovaps %zmm4, %zmm0 {%k1}
retq
vbroadcastss 0x6a300(%rip), %zmm0 # 0xb5e88
retq
vxorps %xmm0, %xmm0, %xmm0
retq
nop
|
/ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx512f.hpp
|
ear::PolarExtentCoreSimd<xsimd::fma3<xsimd::avx2>>::weight_stadium(ear::PolarExtentCoreContext&, ear::PositionBatch<xsimd::batch<float, xsimd::fma3<xsimd::avx2>>> const&) const
|
batch weight_stadium(PolarExtentCoreContext &ctx,
const PositionBatch<batch> &position) const {
PositionBatch<batch> position_t = position.transform(ctx.flippedBasis);
PositionBatch<batch> position_t_right = position_t;
position_t_right.x = xsimd::abs(position_t.x);
auto circle_test_dot =
xsimd::fma(position_t_right.x, batch{ctx.circle_test[0]},
position_t_right.y * batch{ctx.circle_test[1]});
auto in_straight_line_part = circle_test_dot >= batch{0.0};
// for the straight line part
auto straight_val = weight_from_sin(ctx, xsimd::abs(position_t.z));
// for the circle part
auto circle_dot =
xsimd::fma(position_t_right.x, batch{ctx.right_circle_centre[0]},
position_t_right.y * batch{ctx.right_circle_centre[1]});
auto circle_val = weight_from_cos(ctx, circle_dot);
if (xsimd::all(in_straight_line_part))
return straight_val;
else if (xsimd::none(in_straight_line_part))
return circle_val;
else
return xsimd::select(in_straight_line_part, straight_val, circle_val);
}
|
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, %r14
vbroadcastss 0x44(%rsi), %ymm0
vbroadcastss 0x48(%rsi), %ymm1
vbroadcastss 0x4c(%rsi), %ymm2
vmovaps (%rdx), %ymm3
vmovaps 0x20(%rdx), %ymm4
vmovaps 0x40(%rdx), %ymm5
vmulps %ymm2, %ymm5, %ymm2
vfmadd231ps %ymm1, %ymm4, %ymm2 # ymm2 = (ymm4 * ymm1) + ymm2
vfmadd231ps %ymm0, %ymm3, %ymm2 # ymm2 = (ymm3 * ymm0) + ymm2
vbroadcastss 0x50(%rsi), %ymm0
vbroadcastss 0x54(%rsi), %ymm1
vbroadcastss 0x58(%rsi), %ymm6
vmulps %ymm6, %ymm5, %ymm8
vfmadd231ps %ymm1, %ymm4, %ymm8 # ymm8 = (ymm4 * ymm1) + ymm8
vbroadcastss 0x5c(%rsi), %ymm1
vbroadcastss 0x60(%rsi), %ymm6
vbroadcastss 0x64(%rsi), %ymm7
vfmadd231ps %ymm0, %ymm3, %ymm8 # ymm8 = (ymm3 * ymm0) + ymm8
vmovups %ymm8, 0x20(%rsp)
vmulps %ymm7, %ymm5, %ymm0
vfmadd231ps %ymm6, %ymm4, %ymm0 # ymm0 = (ymm4 * ymm6) + ymm0
vfmadd231ps %ymm1, %ymm3, %ymm0 # ymm0 = (ymm3 * ymm1) + ymm0
vbroadcastss 0x80a1b(%rip), %ymm1 # 0xcc888
vbroadcastss 0x68(%rsi), %ymm3
vandps %ymm1, %ymm2, %ymm4
vmovups %ymm4, (%rsp)
vbroadcastss 0x6c(%rsi), %ymm2
vmulps %ymm2, %ymm8, %ymm2
vfmadd231ps %ymm3, %ymm4, %ymm2 # ymm2 = (ymm4 * ymm3) + ymm2
vxorps %xmm3, %xmm3, %xmm3
vcmpleps %ymm2, %ymm3, %ymm2
vmovups %ymm2, 0x60(%rsp)
vandps %ymm1, %ymm0, %ymm0
callq 0x4c07c
vmovups %ymm0, 0x40(%rsp)
vbroadcastss 0x70(%rbx), %ymm1
vbroadcastss 0x74(%rbx), %ymm0
vmulps 0x20(%rsp), %ymm0, %ymm0
vfmadd231ps (%rsp), %ymm1, %ymm0 # ymm0 = (ymm1 * mem) + ymm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4bf06
vmovups 0x60(%rsp), %ymm2
vpcmpeqd %ymm1, %ymm1, %ymm1
vtestps %ymm1, %ymm2
vmovups 0x40(%rsp), %ymm1
jb 0x4bef6
vtestps %ymm2, %ymm2
jne 0x4bef0
vmovaps %ymm0, %ymm1
jmp 0x4bef6
vblendvps %ymm2, %ymm1, %ymm0, %ymm1
vmovaps %ymm1, %ymm0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
nop
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::fma3<xsimd::avx2>>::weight_from_cos(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::fma3<xsimd::avx2>>) const
|
inline batch<float, A> broadcast(float val, requires_arch<avx>) noexcept
{
return _mm256_set1_ps(val);
}
|
vbroadcastss 0x78(%rsi), %ymm1
vcmpleps %ymm0, %ymm1, %ymm2
vpcmpeqd %ymm1, %ymm1, %ymm1
vtestps %ymm1, %ymm2
jae 0x4bf2a
vbroadcastss 0x69f63(%rip), %ymm1 # 0xb5e88
jmp 0x4c077
vmovsd 0x7c(%rsi), %xmm3
vbroadcastss %xmm3, %ymm3
vcmpleps %ymm3, %ymm0, %ymm4
vtestps %ymm1, %ymm4
vxorps %xmm1, %xmm1, %xmm1
jb 0x4c077
vbroadcastss 0x80937(%rip), %ymm5 # 0xcc888
vbroadcastss 0x6446e(%rip), %ymm7 # 0xb03c8
vandps %ymm5, %ymm0, %ymm4
vcmpltps %ymm4, %ymm7, %ymm1
vbroadcastss 0x64454(%rip), %ymm6 # 0xb03c0
vfmadd213ps %ymm7, %ymm6, %ymm4 # ymm4 = (ymm6 * ymm4) + ymm7
vsqrtps %ymm4, %ymm8
vbroadcastss 0x88(%rsi), %ymm4
vblendvps %ymm1, %ymm8, %ymm0, %ymm8
vandps %ymm5, %ymm8, %ymm9
vbroadcastss 0x808fb(%rip), %ymm10 # 0xcc88c
vcmpltps %ymm9, %ymm7, %ymm11
vbroadcastss 0x69ee8(%rip), %ymm5 # 0xb5e88
vsubps %ymm9, %ymm5, %ymm12
vmulps %ymm7, %ymm12, %ymm7
vmulps %ymm8, %ymm8, %ymm12
vblendvps %ymm11, %ymm7, %ymm12, %ymm7
vsqrtps %ymm7, %ymm12
vandps %ymm10, %ymm8, %ymm8
vblendvps %ymm11, %ymm12, %ymm9, %ymm9
vbroadcastss 0x806c0(%rip), %ymm10 # 0xcc68c
vbroadcastss 0x806b3(%rip), %ymm12 # 0xcc688
vfmadd213ps %ymm10, %ymm7, %ymm12 # ymm12 = (ymm7 * ymm12) + ymm10
vbroadcastss 0x806ad(%rip), %ymm10 # 0xcc690
vfmadd231ps %ymm12, %ymm7, %ymm10 # ymm10 = (ymm7 * ymm12) + ymm10
vbroadcastss 0x806a3(%rip), %ymm12 # 0xcc694
vbroadcastss 0x8069e(%rip), %ymm13 # 0xcc698
vfmadd231ps %ymm10, %ymm7, %ymm12 # ymm12 = (ymm7 * ymm10) + ymm12
vfmadd231ps %ymm12, %ymm7, %ymm13 # ymm13 = (ymm7 * ymm12) + ymm13
vmulps %ymm7, %ymm9, %ymm7
vfmadd213ps %ymm9, %ymm13, %ymm7 # ymm7 = (ymm13 * ymm7) + ymm9
vaddps %ymm7, %ymm7, %ymm9
vbroadcastss 0x80682(%rip), %ymm10 # 0xcc69c
vsubps %ymm9, %ymm10, %ymm9
vblendvps %ymm11, %ymm9, %ymm7, %ymm7
vxorps %ymm7, %ymm8, %ymm7
vaddps %ymm7, %ymm7, %ymm8
vblendvps %ymm1, %ymm8, %ymm7, %ymm7
vbroadcastss 0x80664(%rip), %ymm8 # 0xcc6a0
vcmpltps %ymm6, %ymm0, %ymm6
vsubps %ymm7, %ymm8, %ymm8
vblendvps %ymm6, %ymm8, %ymm7, %ymm6
vsubps %ymm6, %ymm10, %ymm7
vblendvps %ymm1, %ymm6, %ymm7, %ymm1
vmulps %ymm4, %ymm1, %ymm1
vmovshdup 0x78(%rsi), %ymm4 # ymm4 = mem[1,1,3,3,5,5,7,7]
vpermpd $0xaa, %ymm4, %ymm4 # ymm4 = ymm4[2,2,2,2]
vaddps %ymm4, %ymm1, %ymm1
vcmpnleps %ymm3, %ymm0, %ymm0
vandps %ymm1, %ymm0, %ymm0
vblendvps %ymm2, %ymm5, %ymm0, %ymm1
vmovaps %ymm1, %ymm0
retq
|
/ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx.hpp
|
ear::PolarExtentCoreSimd<xsimd::avx>::run(ear::PolarExtentCoreContext&) const
|
void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i += batch::size) {
PositionBatch<batch> pos;
pos.x = batch::load_aligned(ctx.xs + i);
pos.y = batch::load_aligned(ctx.ys + i);
pos.z = batch::load_aligned(ctx.zs + i);
batch weight = ctx.is_circular ? weight_circle(ctx, pos)
: weight_stadium(ctx, pos);
bool all_zeros = xsimd::all(weight == 0.0);
bool all_ones = xsimd::all(weight == 1.0);
if (all_ones) {
// add pre-computed sum for this batch
size_t batch_i = i / batch::size;
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx += batch::size) {
batch gain =
batch::load_aligned(ctx.summed_panning_results +
(batch_i * ctx.num_speakers) + speaker_idx);
extent_float_t *result_ptr = ctx.results + speaker_idx;
xsimd::store_aligned(result_ptr,
batch::load_aligned(result_ptr) + gain);
}
} else if (!all_zeros) {
for (size_t speaker_idx = 0; speaker_idx < ctx.real_num_speakers;
speaker_idx++) {
batch gain = batch::load_aligned(ctx.panning_results +
speaker_idx * ctx.num_points + i);
ctx.results[speaker_idx] += xsimd::reduce_add(gain * weight);
}
}
}
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4c221
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x4c3d4
xorl %r12d, %r12d
vxorps %xmm0, %xmm0, %xmm0
vcmptrueps %ymm0, %ymm0, %ymm3
leaq 0x20(%rsp), %r15
xorl %r13d, %r13d
vmovaps %ymm3, (%rsp)
leaq (,%r13,4), %rax
movq 0x18(%rbx), %rcx
addq %rax, %rcx
testb $0x1f, %cl
jne 0x4c3e6
vmovaps (%rcx), %ymm0
vmovaps %ymm0, 0x20(%rsp)
movq 0x20(%rbx), %rcx
addq %rax, %rcx
testb $0x1f, %cl
jne 0x4c3e6
vmovaps (%rcx), %ymm1
vmovaps %ymm1, 0x40(%rsp)
addq 0x28(%rbx), %rax
testb $0x1f, %al
jne 0x4c3e6
vmovaps (%rax), %ymm2
vmovaps %ymm2, 0x60(%rsp)
cmpb $0x1, 0x40(%rbx)
jne 0x4c2cf
vbroadcastss 0x50(%rbx), %ymm3
vbroadcastss 0x54(%rbx), %ymm4
vbroadcastss 0x58(%rbx), %ymm5
vmulps %ymm5, %ymm2, %ymm2
vmulps %ymm4, %ymm1, %ymm1
vaddps %ymm2, %ymm1, %ymm1
vmulps %ymm3, %ymm0, %ymm0
vaddps %ymm1, %ymm0, %ymm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c54e
jmp 0x4c2dd
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4c408
vbroadcastss 0x69ba2(%rip), %ymm1 # 0xb5e88
vcmpeqps %ymm1, %ymm0, %ymm1
vmovaps (%rsp), %ymm3
vtestps %ymm3, %ymm1
jae 0x4c35a
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x4c3c3
movq %r13, %rax
shrq $0x3, %rax
xorl %ecx, %ecx
imulq %rax, %rdx
shlq $0x2, %rdx
addq 0x38(%rbx), %rdx
leaq (%rdx,%rcx,4), %rdx
testb $0x1f, %dl
jne 0x4c3e6
leaq (,%rcx,4), %rsi
addq 0x90(%rbx), %rsi
testb $0x1f, %sil
jne 0x4c3e6
vmovaps (%rdx), %ymm0
vaddps (%rsi), %ymm0, %ymm0
vmovaps %ymm0, (%rsi)
addq $0x8, %rcx
movq 0x8(%rbx), %rdx
cmpq %rdx, %rcx
jb 0x4c30d
jmp 0x4c3c3
vcmpeqps 0x8053d(%rip), %ymm0, %ymm1 # 0xcc8a0
vtestps %ymm3, %ymm1
jb 0x4c3c3
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4c3c3
movq (%rbx), %rcx
movq 0x30(%rbx), %rdx
movq 0x90(%rbx), %rsi
shlq $0x2, %rcx
movq %r12, %rdi
xorl %r8d, %r8d
leal (%rdx,%rdi), %r9d
testb $0x1f, %r9b
jne 0x4c3e6
vmulps (%rdx,%rdi), %ymm0, %ymm1
vextractf128 $0x1, %ymm1, %xmm2
vaddps %xmm2, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vhaddps %xmm1, %xmm1, %xmm1
vaddss (%rsi,%r8,4), %xmm1, %xmm1
vmovss %xmm1, (%rsi,%r8,4)
incq %r8
addq %rcx, %rdi
cmpq %r8, %rax
jne 0x4c38b
addq $0x8, %r13
addq $0x20, %r12
cmpq (%rbx), %r13
jb 0x4c244
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
leaq 0x80352(%rip), %rdi # 0xcc73f
leaq 0x803b2(%rip), %rsi # 0xcc7a6
leaq 0x80594(%rip), %rcx # 0xcc98f
movl $0x268, %edx # imm = 0x268
vzeroupper
callq 0x143c0
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::avx>::weight_stadium(ear::PolarExtentCoreContext&, ear::PositionBatch<xsimd::batch<float, xsimd::avx>> const&) const
|
batch weight_stadium(PolarExtentCoreContext &ctx,
const PositionBatch<batch> &position) const {
PositionBatch<batch> position_t = position.transform(ctx.flippedBasis);
PositionBatch<batch> position_t_right = position_t;
position_t_right.x = xsimd::abs(position_t.x);
auto circle_test_dot =
xsimd::fma(position_t_right.x, batch{ctx.circle_test[0]},
position_t_right.y * batch{ctx.circle_test[1]});
auto in_straight_line_part = circle_test_dot >= batch{0.0};
// for the straight line part
auto straight_val = weight_from_sin(ctx, xsimd::abs(position_t.z));
// for the circle part
auto circle_dot =
xsimd::fma(position_t_right.x, batch{ctx.right_circle_centre[0]},
position_t_right.y * batch{ctx.right_circle_centre[1]});
auto circle_val = weight_from_cos(ctx, circle_dot);
if (xsimd::all(in_straight_line_part))
return straight_val;
else if (xsimd::none(in_straight_line_part))
return circle_val;
else
return xsimd::select(in_straight_line_part, straight_val, circle_val);
}
|
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
vbroadcastss 0x44(%rsi), %ymm0
vbroadcastss 0x48(%rsi), %ymm1
vbroadcastss 0x4c(%rsi), %ymm2
movq %rdi, %r14
vmovaps (%rdx), %ymm3
vmovaps 0x20(%rdx), %ymm4
vmovaps 0x40(%rdx), %ymm5
vmulps %ymm2, %ymm5, %ymm2
vmulps %ymm4, %ymm1, %ymm1
vaddps %ymm2, %ymm1, %ymm1
vmulps %ymm3, %ymm0, %ymm0
vbroadcastss 0x50(%rsi), %ymm2
vbroadcastss 0x54(%rsi), %ymm6
vaddps %ymm1, %ymm0, %ymm0
vbroadcastss 0x58(%rsi), %ymm1
vmulps %ymm1, %ymm5, %ymm1
vmulps %ymm6, %ymm4, %ymm6
vaddps %ymm1, %ymm6, %ymm1
vmulps %ymm2, %ymm3, %ymm2
vaddps %ymm1, %ymm2, %ymm7
vmovups %ymm7, 0x40(%rsp)
vbroadcastss 0x5c(%rsi), %ymm1
vbroadcastss 0x60(%rsi), %ymm2
vbroadcastss 0x64(%rsi), %ymm6
vmulps %ymm6, %ymm5, %ymm5
vmulps %ymm2, %ymm4, %ymm2
vaddps %ymm5, %ymm2, %ymm2
vmulps %ymm1, %ymm3, %ymm1
vbroadcastss 0x803e5(%rip), %ymm3 # 0xcc888
vaddps %ymm2, %ymm1, %ymm1
vandps %ymm3, %ymm0, %ymm4
vmovups %ymm4, 0x20(%rsp)
vbroadcastss 0x68(%rsi), %ymm0
vbroadcastss 0x6c(%rsi), %ymm2
vmulps %ymm2, %ymm7, %ymm2
vmulps %ymm0, %ymm4, %ymm0
vaddps %ymm2, %ymm0, %ymm0
vxorps %xmm2, %xmm2, %xmm2
vcmpleps %ymm0, %ymm2, %ymm0
vmovups %ymm0, 0x60(%rsp)
vandps %ymm3, %ymm1, %ymm0
callq 0x4c6de
vbroadcastss 0x70(%rbx), %ymm1
vbroadcastss 0x74(%rbx), %ymm2
vmovups %ymm0, (%rsp)
vmulps 0x40(%rsp), %ymm2, %ymm0
vmulps 0x20(%rsp), %ymm1, %ymm1
vaddps %ymm0, %ymm1, %ymm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4c54e
vmovups (%rsp), %ymm2
vxorps %xmm1, %xmm1, %xmm1
vcmptrueps %ymm1, %ymm1, %ymm1
vmovups 0x60(%rsp), %ymm3
vtestps %ymm1, %ymm3
jb 0x4c53f
vmovaps %ymm3, %ymm1
vtestps %ymm3, %ymm3
jne 0x4c539
vmovaps %ymm0, %ymm2
jmp 0x4c53f
vblendvps %ymm1, %ymm2, %ymm0, %ymm2
vmovaps %ymm2, %ymm0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::avx>::weight_from_cos(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::avx>) const
|
inline batch<float, A> broadcast(float val, requires_arch<avx>) noexcept
{
return _mm256_set1_ps(val);
}
|
vbroadcastss 0x78(%rsi), %ymm1
vcmpleps %ymm0, %ymm1, %ymm2
vxorps %xmm1, %xmm1, %xmm1
vcmptrueps %ymm1, %ymm1, %ymm4
vtestps %ymm4, %ymm2
jae 0x4c577
vbroadcastss 0x69916(%rip), %ymm1 # 0xb5e88
jmp 0x4c6d8
vbroadcastss 0x7c(%rsi), %ymm3
vcmpleps %ymm3, %ymm0, %ymm5
vtestps %ymm4, %ymm5
jb 0x4c6d8
vpermilps $0x0, 0x88(%rsi), %xmm5 # xmm5 = mem[0,0,0,0]
vbroadcastss 0x802e8(%rip), %ymm1 # 0xcc888
vandps %ymm1, %ymm0, %ymm4
vbroadcastss 0x63e1b(%rip), %ymm6 # 0xb03c8
vmulps %ymm6, %ymm4, %ymm7
vsubps %ymm7, %ymm6, %ymm7
vsqrtps %ymm7, %ymm7
vcmpltps %ymm4, %ymm6, %ymm4
vblendvps %ymm4, %ymm7, %ymm0, %ymm7
vandps %ymm1, %ymm7, %ymm8
vcmpltps %ymm8, %ymm6, %ymm9
vbroadcastss 0x698b1(%rip), %ymm1 # 0xb5e88
vsubps %ymm8, %ymm1, %ymm10
vmulps %ymm6, %ymm10, %ymm6
vmulps %ymm7, %ymm7, %ymm10
vblendvps %ymm9, %ymm6, %ymm10, %ymm6
vinsertf128 $0x1, %xmm5, %ymm5, %ymm5
vsqrtps %ymm6, %ymm10
vbroadcastss 0x8028f(%rip), %ymm11 # 0xcc88c
vblendvps %ymm9, %ymm10, %ymm8, %ymm8
vandps %ymm7, %ymm11, %ymm7
vbroadcastss 0x80078(%rip), %ymm10 # 0xcc688
vmulps %ymm6, %ymm10, %ymm10
vbroadcastss 0x8006f(%rip), %ymm11 # 0xcc68c
vaddps %ymm11, %ymm10, %ymm10
vmulps %ymm6, %ymm10, %ymm10
vbroadcastss 0x80061(%rip), %ymm11 # 0xcc690
vaddps %ymm11, %ymm10, %ymm10
vmulps %ymm6, %ymm10, %ymm10
vbroadcastss 0x80053(%rip), %ymm11 # 0xcc694
vaddps %ymm11, %ymm10, %ymm10
vmulps %ymm6, %ymm10, %ymm10
vbroadcastss 0x80045(%rip), %ymm11 # 0xcc698
vaddps %ymm11, %ymm10, %ymm10
vmulps %ymm6, %ymm8, %ymm6
vmulps %ymm6, %ymm10, %ymm6
vaddps %ymm6, %ymm8, %ymm6
vbroadcastss 0x8002f(%rip), %ymm8 # 0xcc69c
vaddps %ymm6, %ymm6, %ymm10
vsubps %ymm10, %ymm8, %ymm10
vblendvps %ymm9, %ymm10, %ymm6, %ymm6
vxorps %ymm6, %ymm7, %ymm6
vaddps %ymm6, %ymm6, %ymm7
vblendvps %ymm4, %ymm7, %ymm6, %ymm6
vbroadcastss 0x63d2d(%rip), %ymm7 # 0xb03c0
vbroadcastss 0x80004(%rip), %ymm9 # 0xcc6a0
vcmpltps %ymm7, %ymm0, %ymm7
vsubps %ymm6, %ymm9, %ymm9
vblendvps %ymm7, %ymm9, %ymm6, %ymm6
vsubps %ymm6, %ymm8, %ymm7
vblendvps %ymm4, %ymm6, %ymm7, %ymm4
vmulps %ymm5, %ymm4, %ymm4
vperm2f128 $0x33, 0x78(%rsi), %ymm0, %ymm5 # ymm5 = mem[2,3,2,3]
vshufps $0x55, %ymm5, %ymm5, %ymm5 # ymm5 = ymm5[1,1,1,1,5,5,5,5]
vaddps %ymm5, %ymm4, %ymm4
vcmpnleps %ymm3, %ymm0, %ymm0
vandps %ymm4, %ymm0, %ymm0
vblendvps %ymm2, %ymm1, %ymm0, %ymm1
vmovaps %ymm1, %ymm0
retq
nop
|
/ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx.hpp
|
ear::PolarExtentCoreSimd<xsimd::avx>::weight_from_sin(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::avx>) const
|
inline batch<float, A> broadcast(float val, requires_arch<avx>) noexcept
{
return _mm256_set1_ps(val);
}
|
vbroadcastss 0x80(%rsi), %ymm1
vcmpleps %ymm1, %ymm0, %ymm2
vxorps %xmm1, %xmm1, %xmm1
vcmptrueps %ymm1, %ymm1, %ymm4
vtestps %ymm4, %ymm2
jae 0x4c70a
vbroadcastss 0x69783(%rip), %ymm1 # 0xb5e88
jmp 0x4c811
vbroadcastss 0x84(%rsi), %ymm3
vcmpleps %ymm0, %ymm3, %ymm5
vtestps %ymm4, %ymm5
jb 0x4c811
vbroadcastss 0x88(%rsi), %ymm1
vbroadcastss 0x80153(%rip), %ymm4 # 0xcc888
vandps %ymm4, %ymm0, %ymm5
vbroadcastss 0x8014a(%rip), %ymm6 # 0xcc88c
vbroadcastss 0x63c7d(%rip), %ymm7 # 0xb03c8
vcmpltps %ymm5, %ymm7, %ymm8
vbroadcastss 0x6972f(%rip), %ymm4 # 0xb5e88
vsubps %ymm5, %ymm4, %ymm9
vmulps %ymm7, %ymm9, %ymm7
vmulps %ymm0, %ymm0, %ymm9
vblendvps %ymm8, %ymm7, %ymm9, %ymm7
vsqrtps %ymm7, %ymm9
vandps %ymm6, %ymm0, %ymm6
vblendvps %ymm8, %ymm9, %ymm5, %ymm5
vbroadcastss 0x7ff06(%rip), %ymm9 # 0xcc688
vbroadcastss 0x7ff01(%rip), %ymm10 # 0xcc68c
vmulps %ymm7, %ymm9, %ymm9
vaddps %ymm10, %ymm9, %ymm9
vbroadcastss 0x7fef3(%rip), %ymm10 # 0xcc690
vmulps %ymm7, %ymm9, %ymm9
vaddps %ymm10, %ymm9, %ymm9
vbroadcastss 0x7fee5(%rip), %ymm10 # 0xcc694
vmulps %ymm7, %ymm9, %ymm9
vaddps %ymm10, %ymm9, %ymm9
vbroadcastss 0x7fed7(%rip), %ymm10 # 0xcc698
vmulps %ymm7, %ymm9, %ymm9
vaddps %ymm10, %ymm9, %ymm9
vmulps %ymm5, %ymm7, %ymm7
vmulps %ymm7, %ymm9, %ymm7
vaddps %ymm7, %ymm5, %ymm5
vaddps %ymm5, %ymm5, %ymm7
vbroadcastss 0x7feb9(%rip), %ymm9 # 0xcc69c
vsubps %ymm7, %ymm9, %ymm7
vblendvps %ymm8, %ymm7, %ymm5, %ymm5
vxorps %ymm5, %ymm6, %ymm5
vmulps %ymm5, %ymm1, %ymm1
vbroadcastss 0x8c(%rsi), %ymm5
vaddps %ymm5, %ymm1, %ymm1
vcmpnleps %ymm0, %ymm3, %ymm0
vandps %ymm1, %ymm0, %ymm0
vblendvps %ymm2, %ymm4, %ymm0, %ymm1
vmovaps %ymm1, %ymm0
retq
nop
|
/ebu[P]libear/submodules/xsimd/include/xsimd/types/../arch/./xsimd_avx.hpp
|
ear::PolarExtentCoreSimd<xsimd::sse4_2>::run(ear::PolarExtentCoreContext&) const
|
void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i += batch::size) {
PositionBatch<batch> pos;
pos.x = batch::load_aligned(ctx.xs + i);
pos.y = batch::load_aligned(ctx.ys + i);
pos.z = batch::load_aligned(ctx.zs + i);
batch weight = ctx.is_circular ? weight_circle(ctx, pos)
: weight_stadium(ctx, pos);
bool all_zeros = xsimd::all(weight == 0.0);
bool all_ones = xsimd::all(weight == 1.0);
if (all_ones) {
// add pre-computed sum for this batch
size_t batch_i = i / batch::size;
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx += batch::size) {
batch gain =
batch::load_aligned(ctx.summed_panning_results +
(batch_i * ctx.num_speakers) + speaker_idx);
extent_float_t *result_ptr = ctx.results + speaker_idx;
xsimd::store_aligned(result_ptr,
batch::load_aligned(result_ptr) + gain);
}
} else if (!all_zeros) {
for (size_t speaker_idx = 0; speaker_idx < ctx.real_num_speakers;
speaker_idx++) {
batch gain = batch::load_aligned(ctx.panning_results +
speaker_idx * ctx.num_points + i);
ctx.results[speaker_idx] += xsimd::reduce_add(gain * weight);
}
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4c88e
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x4ca1a
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r13d, %r13d
leaq (,%r13,4), %rax
movq 0x18(%rbx), %rcx
addq %rax, %rcx
testb $0xf, %cl
jne 0x4ca28
movaps (%rcx), %xmm0
movaps %xmm0, (%rsp)
movq 0x20(%rbx), %rcx
addq %rax, %rcx
testb $0xf, %cl
jne 0x4ca28
movaps (%rcx), %xmm1
movaps %xmm1, 0x10(%rsp)
addq 0x28(%rbx), %rax
testb $0xf, %al
jne 0x4ca28
movaps (%rax), %xmm2
movaps %xmm2, 0x20(%rsp)
cmpb $0x1, 0x40(%rbx)
jne 0x4c926
movups 0x50(%rbx), %xmm3
movups 0x54(%rbx), %xmm4
movups 0x58(%rbx), %xmm5
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
mulps %xmm5, %xmm2
mulps %xmm4, %xmm1
addps %xmm2, %xmm1
mulps %xmm3, %xmm0
addps %xmm1, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4cb80
jmp 0x4c934
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4ca48
movaps %xmm0, %xmm1
cmpneqps 0x800c1(%rip), %xmm1 # 0xcca00
movmskps %xmm1, %eax
testl %eax, %eax
je 0x4c9b7
movaps %xmm0, %xmm1
cmpneqps 0x6274f(%rip), %xmm1 # 0xaf0a0
movmskps %xmm1, %eax
testl %eax, %eax
je 0x4ca09
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4ca09
movq (%rbx), %rcx
movq 0x30(%rbx), %rdx
movq 0x90(%rbx), %rsi
shlq $0x2, %rcx
movq %r12, %rdi
xorl %r8d, %r8d
leal (%rdx,%rdi), %r9d
testb $0xf, %r9b
jne 0x4ca28
movaps (%rdx,%rdi), %xmm1
mulps %xmm0, %xmm1
haddps %xmm1, %xmm1
haddps %xmm1, %xmm1
addss (%rsi,%r8,4), %xmm1
movss %xmm1, (%rsi,%r8,4)
incq %r8
addq %rcx, %rdi
cmpq %r8, %rax
jne 0x4c981
jmp 0x4ca09
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x4ca09
movq %r13, %rax
shrq $0x2, %rax
xorl %ecx, %ecx
imulq %rax, %rdx
shlq $0x2, %rdx
addq 0x38(%rbx), %rdx
leaq (%rdx,%rcx,4), %rdx
testb $0xf, %dl
jne 0x4ca28
leaq (,%rcx,4), %rsi
addq 0x90(%rbx), %rsi
testb $0xf, %sil
jne 0x4ca28
movaps (%rdx), %xmm0
addps (%rsi), %xmm0
movaps %xmm0, (%rsi)
addq $0x4, %rcx
movq 0x8(%rbx), %rdx
cmpq %rdx, %rcx
jb 0x4c9c9
addq $0x4, %r13
addq $0x10, %r12
cmpq (%rbx), %r13
jb 0x4c8a1
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x7fd10(%rip), %rdi # 0xcc73f
leaq 0x7fd70(%rip), %rsi # 0xcc7a6
leaq 0x800a0(%rip), %rcx # 0xccadd
movl $0x268, %edx # imm = 0x268
callq 0x143c0
nop
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::sse4_2>::weight_from_sin(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::sse4_2>) const
|
batch weight_from_sin(PolarExtentCoreContext &ctx, batch sin_angle) const {
auto start = sin_angle <= ctx.sin_start_angle;
auto end = sin_angle >= ctx.sin_end_angle;
if (xsimd::all(start)) return batch{1.0};
if (xsimd::all(end)) return batch{0.0};
auto ramp = ctx.m * xsimd::asin(sin_angle) + ctx.c;
return xsimd::select(start, batch{1.0},
xsimd::select(end, batch{0.0}, ramp));
}
|
movaps %xmm0, %xmm1
movups 0x80(%rsi), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm1, %xmm2
cmpnleps %xmm0, %xmm2
movmskps %xmm2, %eax
testl %eax, %eax
je 0x4ce00
movups 0x84(%rsi), %xmm4
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
cmpnleps %xmm1, %xmm4
movmskps %xmm4, %eax
testl %eax, %eax
je 0x4ce09
movups 0x88(%rsi), %xmm5
movaps %xmm5, %xmm6
movaps 0x7fccc(%rip), %xmm8 # 0xcca10
andps %xmm1, %xmm8
movaps 0x62341(%rip), %xmm7 # 0xaf090
andps %xmm1, %xmm7
movaps 0x7fcc7(%rip), %xmm0 # 0xcca20
movaps 0x7fca0(%rip), %xmm3 # 0xcca00
movaps %xmm3, %xmm9
subps %xmm8, %xmm9
mulps %xmm0, %xmm9
cmpltps %xmm8, %xmm0
mulps %xmm1, %xmm1
blendvps %xmm0, %xmm9, %xmm1
sqrtps %xmm1, %xmm9
blendvps %xmm0, %xmm9, %xmm8
movaps 0x7fca4(%rip), %xmm9 # 0xcca30
mulps %xmm1, %xmm9
addps 0x7fca8(%rip), %xmm9 # 0xcca40
shufps $0x0, %xmm5, %xmm6 # xmm6 = xmm6[0,0],xmm5[0,0]
mulps %xmm1, %xmm9
addps 0x7fca8(%rip), %xmm9 # 0xcca50
mulps %xmm1, %xmm9
addps 0x7fcac(%rip), %xmm9 # 0xcca60
mulps %xmm1, %xmm9
addps 0x7fcb0(%rip), %xmm9 # 0xcca70
mulps %xmm8, %xmm1
mulps %xmm9, %xmm1
addps %xmm8, %xmm1
movaps %xmm1, %xmm8
addps %xmm1, %xmm8
movaps 0x7fca4(%rip), %xmm9 # 0xcca80
subps %xmm8, %xmm9
blendvps %xmm0, %xmm9, %xmm1
xorps %xmm7, %xmm1
mulps %xmm6, %xmm1
shufps $0x55, %xmm5, %xmm5 # xmm5 = xmm5[1,1,1,1]
addps %xmm1, %xmm5
andps %xmm5, %xmm4
movaps %xmm2, %xmm0
blendvps %xmm0, %xmm4, %xmm3
jmp 0x4ce0c
movaps 0x7fbf9(%rip), %xmm3 # 0xcca00
jmp 0x4ce0c
xorps %xmm3, %xmm3
movaps %xmm3, %xmm0
retq
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::sse2>::run(ear::PolarExtentCoreContext&) const
|
void run(PolarExtentCoreContext &ctx) const override {
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx++)
ctx.results[speaker_idx] = 0.0;
for (size_t i = 0; i < ctx.num_points; i += batch::size) {
PositionBatch<batch> pos;
pos.x = batch::load_aligned(ctx.xs + i);
pos.y = batch::load_aligned(ctx.ys + i);
pos.z = batch::load_aligned(ctx.zs + i);
batch weight = ctx.is_circular ? weight_circle(ctx, pos)
: weight_stadium(ctx, pos);
bool all_zeros = xsimd::all(weight == 0.0);
bool all_ones = xsimd::all(weight == 1.0);
if (all_ones) {
// add pre-computed sum for this batch
size_t batch_i = i / batch::size;
for (size_t speaker_idx = 0; speaker_idx < ctx.num_speakers;
speaker_idx += batch::size) {
batch gain =
batch::load_aligned(ctx.summed_panning_results +
(batch_i * ctx.num_speakers) + speaker_idx);
extent_float_t *result_ptr = ctx.results + speaker_idx;
xsimd::store_aligned(result_ptr,
batch::load_aligned(result_ptr) + gain);
}
} else if (!all_zeros) {
for (size_t speaker_idx = 0; speaker_idx < ctx.real_num_speakers;
speaker_idx++) {
batch gain = batch::load_aligned(ctx.panning_results +
speaker_idx * ctx.num_points + i);
ctx.results[speaker_idx] += xsimd::reduce_add(gain * weight);
}
}
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x4ce86
movq 0x90(%rbx), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x14330
cmpq $0x0, (%rbx)
je 0x4d01f
xorl %r12d, %r12d
movq %rsp, %r15
xorl %r13d, %r13d
leaq (,%r13,4), %rax
movq 0x18(%rbx), %rcx
addq %rax, %rcx
testb $0xf, %cl
jne 0x4d02d
movaps (%rcx), %xmm0
movaps %xmm0, (%rsp)
movq 0x20(%rbx), %rcx
addq %rax, %rcx
testb $0xf, %cl
jne 0x4d02d
movaps (%rcx), %xmm1
movaps %xmm1, 0x10(%rsp)
addq 0x28(%rbx), %rax
testb $0xf, %al
jne 0x4d02d
movaps (%rax), %xmm2
movaps %xmm2, 0x20(%rsp)
cmpb $0x1, 0x40(%rbx)
jne 0x4cf1e
movups 0x50(%rbx), %xmm3
movups 0x54(%rbx), %xmm4
movups 0x58(%rbx), %xmm5
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
mulps %xmm5, %xmm2
mulps %xmm4, %xmm1
addps %xmm2, %xmm1
mulps %xmm3, %xmm0
addps %xmm1, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d18e
jmp 0x4cf2c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4d04c
movaps %xmm0, %xmm1
cmpneqps 0x7fac9(%rip), %xmm1 # 0xcca00
movmskps %xmm1, %eax
testl %eax, %eax
je 0x4cfbc
movaps %xmm0, %xmm1
cmpneqps 0x62157(%rip), %xmm1 # 0xaf0a0
movmskps %xmm1, %eax
testl %eax, %eax
je 0x4d00e
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4d00e
movq (%rbx), %rcx
movq 0x30(%rbx), %rdx
movq 0x90(%rbx), %rsi
shlq $0x2, %rcx
movq %r12, %rdi
xorl %r8d, %r8d
leal (%rdx,%rdi), %r9d
testb $0xf, %r9b
jne 0x4d02d
movaps (%rdx,%rdi), %xmm1
mulps %xmm0, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm2 # xmm2 = xmm2[1],xmm1[1]
addps %xmm1, %xmm2
movaps %xmm2, %xmm1
shufps $0x55, %xmm2, %xmm1 # xmm1 = xmm1[1,1],xmm2[1,1]
addss %xmm2, %xmm1
addss (%rsi,%r8,4), %xmm1
movss %xmm1, (%rsi,%r8,4)
incq %r8
addq %rcx, %rdi
cmpq %r8, %rax
jne 0x4cf79
jmp 0x4d00e
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x4d00e
movq %r13, %rax
shrq $0x2, %rax
xorl %ecx, %ecx
imulq %rax, %rdx
shlq $0x2, %rdx
addq 0x38(%rbx), %rdx
leaq (%rdx,%rcx,4), %rdx
testb $0xf, %dl
jne 0x4d02d
leaq (,%rcx,4), %rsi
addq 0x90(%rbx), %rsi
testb $0xf, %sil
jne 0x4d02d
movaps (%rdx), %xmm0
addps (%rsi), %xmm0
movaps %xmm0, (%rsi)
addq $0x4, %rcx
movq 0x8(%rbx), %rdx
cmpq %rdx, %rcx
jb 0x4cfce
addq $0x4, %r13
addq $0x10, %r12
cmpq (%rbx), %r13
jb 0x4ce99
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x7f70b(%rip), %rdi # 0xcc73f
leaq 0x7f76b(%rip), %rsi # 0xcc7a6
leaq 0x7fb30(%rip), %rcx # 0xccb72
movl $0x268, %edx # imm = 0x268
callq 0x143c0
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::sse2>::weight_stadium(ear::PolarExtentCoreContext&, ear::PositionBatch<xsimd::batch<float, xsimd::sse2>> const&) const
|
batch weight_stadium(PolarExtentCoreContext &ctx,
const PositionBatch<batch> &position) const {
PositionBatch<batch> position_t = position.transform(ctx.flippedBasis);
PositionBatch<batch> position_t_right = position_t;
position_t_right.x = xsimd::abs(position_t.x);
auto circle_test_dot =
xsimd::fma(position_t_right.x, batch{ctx.circle_test[0]},
position_t_right.y * batch{ctx.circle_test[1]});
auto in_straight_line_part = circle_test_dot >= batch{0.0};
// for the straight line part
auto straight_val = weight_from_sin(ctx, xsimd::abs(position_t.z));
// for the circle part
auto circle_dot =
xsimd::fma(position_t_right.x, batch{ctx.right_circle_centre[0]},
position_t_right.y * batch{ctx.right_circle_centre[1]});
auto circle_val = weight_from_cos(ctx, circle_dot);
if (xsimd::all(in_straight_line_part))
return straight_val;
else if (xsimd::none(in_straight_line_part))
return circle_val;
else
return xsimd::select(in_straight_line_part, straight_val, circle_val);
}
|
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movups 0x44(%rsi), %xmm5
movups 0x48(%rsi), %xmm0
movups 0x4c(%rsi), %xmm4
movups 0x50(%rsi), %xmm6
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
movaps (%rdx), %xmm1
movaps 0x10(%rdx), %xmm2
movaps 0x20(%rdx), %xmm3
mulps %xmm3, %xmm4
mulps %xmm2, %xmm0
addps %xmm4, %xmm0
mulps %xmm1, %xmm5
addps %xmm0, %xmm5
movaps %xmm5, %xmm7
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
movups 0x54(%rsi), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movups 0x58(%rsi), %xmm4
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
mulps %xmm3, %xmm4
mulps %xmm2, %xmm0
addps %xmm4, %xmm0
mulps %xmm1, %xmm6
addps %xmm0, %xmm6
movaps %xmm6, 0x10(%rsp)
movups 0x5c(%rsi), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movups 0x60(%rsi), %xmm4
shufps $0x0, %xmm4, %xmm4 # xmm4 = xmm4[0,0,0,0]
movups 0x64(%rsi), %xmm5
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
mulps %xmm3, %xmm5
mulps %xmm2, %xmm4
addps %xmm5, %xmm4
mulps %xmm1, %xmm0
addps %xmm4, %xmm0
movaps 0x7f928(%rip), %xmm1 # 0xcca10
andps %xmm1, %xmm7
movaps %xmm7, 0x20(%rsp)
movups 0x68(%rsi), %xmm3
shufps $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
movups 0x6c(%rsi), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
mulps %xmm6, %xmm2
mulps %xmm7, %xmm3
addps %xmm2, %xmm3
movaps %xmm3, 0x30(%rsp)
andps %xmm1, %xmm0
callq 0x4d330
movaps %xmm0, (%rsp)
movups 0x70(%rbx), %xmm0
movups 0x74(%rbx), %xmm1
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
mulps 0x10(%rsp), %xmm1
mulps 0x20(%rsp), %xmm0
addps %xmm1, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d18e
movaps 0x30(%rsp), %xmm2
xorps %xmm1, %xmm1
cmpnleps %xmm2, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
je 0x4d179
xorps %xmm1, %xmm1
cmpleps %xmm2, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
je 0x4d17f
xorps %xmm1, %xmm1
cmpleps %xmm2, %xmm1
movaps (%rsp), %xmm2
andps %xmm1, %xmm2
andnps %xmm0, %xmm1
orps %xmm1, %xmm2
jmp 0x4d182
movaps (%rsp), %xmm2
jmp 0x4d182
movaps %xmm0, %xmm2
movaps %xmm2, %xmm0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::PolarExtentCoreSimd<xsimd::sse2>::weight_from_sin(ear::PolarExtentCoreContext&, xsimd::batch<float, xsimd::sse2>) const
|
batch weight_from_sin(PolarExtentCoreContext &ctx, batch sin_angle) const {
auto start = sin_angle <= ctx.sin_start_angle;
auto end = sin_angle >= ctx.sin_end_angle;
if (xsimd::all(start)) return batch{1.0};
if (xsimd::all(end)) return batch{0.0};
auto ramp = ctx.m * xsimd::asin(sin_angle) + ctx.c;
return xsimd::select(start, batch{1.0},
xsimd::select(end, batch{0.0}, ramp));
}
|
movaps %xmm0, %xmm1
movups 0x80(%rsi), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps %xmm1, %xmm2
cmpnleps %xmm0, %xmm2
movmskps %xmm2, %eax
testl %eax, %eax
je 0x4d44b
movups 0x84(%rsi), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
cmpnleps %xmm1, %xmm0
movmskps %xmm0, %eax
testl %eax, %eax
je 0x4d453
movups 0x88(%rsi), %xmm3
movaps %xmm3, %xmm4
movaps 0x7f695(%rip), %xmm7 # 0xcca10
andps %xmm1, %xmm7
movaps 0x61d0b(%rip), %xmm6 # 0xaf090
andps %xmm1, %xmm6
movaps 0x7f691(%rip), %xmm5 # 0xcca20
movaps 0x7f669(%rip), %xmm8 # 0xcca00
subps %xmm7, %xmm8
mulps %xmm5, %xmm8
cmpnltps %xmm7, %xmm5
mulps %xmm1, %xmm1
movaps %xmm5, %xmm9
andnps %xmm8, %xmm9
andps %xmm5, %xmm1
orps %xmm9, %xmm1
sqrtps %xmm1, %xmm8
movaps %xmm5, %xmm9
andnps %xmm8, %xmm9
movaps 0x7f667(%rip), %xmm8 # 0xcca30
mulps %xmm1, %xmm8
addps 0x7f66b(%rip), %xmm8 # 0xcca40
shufps $0x0, %xmm3, %xmm4 # xmm4 = xmm4[0,0],xmm3[0,0]
mulps %xmm1, %xmm8
addps 0x7f66b(%rip), %xmm8 # 0xcca50
andps %xmm5, %xmm7
mulps %xmm1, %xmm8
addps 0x7f66c(%rip), %xmm8 # 0xcca60
orps %xmm9, %xmm7
mulps %xmm1, %xmm8
addps 0x7f66c(%rip), %xmm8 # 0xcca70
mulps %xmm7, %xmm1
mulps %xmm8, %xmm1
addps %xmm7, %xmm1
movaps %xmm1, %xmm7
addps %xmm1, %xmm7
movaps 0x7f664(%rip), %xmm8 # 0xcca80
subps %xmm7, %xmm8
andps %xmm5, %xmm1
andnps %xmm8, %xmm5
orps %xmm1, %xmm5
xorps %xmm6, %xmm5
mulps %xmm4, %xmm5
shufps $0x55, %xmm3, %xmm3 # xmm3 = xmm3[1,1,1,1]
movaps %xmm2, %xmm1
andnps 0x7f5c2(%rip), %xmm1 # 0xcca00
addps %xmm5, %xmm3
andps %xmm2, %xmm0
andps %xmm3, %xmm0
orps %xmm1, %xmm0
retq
movaps 0x7f5ae(%rip), %xmm0 # 0xcca00
retq
xorps %xmm0, %xmm0
retq
nop
|
/ebu[P]libear/src/object_based/polar_extent_simd.hpp
|
ear::distance(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
|
EIGEN_STRONG_INLINE Packet2d ploadu<Packet2d>(const double* from)
{
EIGEN_DEBUG_UNALIGNED_LOAD
return _mm_loadu_pd(from);
}
|
movupd (%rdi), %xmm0
mulpd %xmm0, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
retq
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/arch/SSE/PacketMath.h
|
ear::cart(double, double, double)
|
Eigen::Vector3d cart(double azimuth, double elevation, double distance) {
return Eigen::Vector3d(
sin(radians(-azimuth)) * cos(radians(elevation)) * distance,
cos(radians(-azimuth)) * cos(radians(elevation)) * distance,
sin(radians(elevation)) * distance);
}
|
pushq %rbx
subq $0x60, %rsp
movaps %xmm2, 0x50(%rsp)
movsd %xmm1, 0x8(%rsp)
movq %rdi, %rbx
mulsd 0x7f125(%rip), %xmm0 # 0xccbf0
movsd %xmm0, 0x10(%rsp)
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x682f6(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14130
movapd 0x50(%rsp), %xmm1
mulsd %xmm1, %xmm0
movapd 0x40(%rsp), %xmm2
unpcklpd 0x10(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm3
unpcklpd 0x20(%rsp), %xmm3 # xmm3 = xmm3[0],mem[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm3, %xmm1
movupd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
|
/ebu[P]libear/src/common/geom.cpp
|
ear::toCartesianVector3d(ear::PolarSpeakerPosition)
|
Eigen::Vector3d toCartesianVector3d(PolarSpeakerPosition position) {
return cart(position.azimuth, position.elevation, position.distance);
}
|
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm1
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x50(%rsi), %xmm0
movaps %xmm0, 0x50(%rsp)
mulsd 0x7f041(%rip), %xmm1 # 0xccbf0
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x6820e(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14130
movapd 0x50(%rsp), %xmm1
mulsd %xmm1, %xmm0
movapd 0x40(%rsp), %xmm2
unpcklpd 0x10(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm3
unpcklpd 0x20(%rsp), %xmm3 # xmm3 = xmm3[0],mem[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm3, %xmm1
movupd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
|
/ebu[P]libear/src/common/geom.cpp
|
ear::toCartesianVector3d(boost::variant<ear::PolarSpeakerPosition, ear::CartesianSpeakerPosition>)
|
Eigen::Vector3d toCartesianVector3d(SpeakerPosition position) {
return boost::apply_visitor(
[](const auto& p) { return toCartesianVector3d(p); }, position);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp # imm = 0x130
movq %rdi, %rbx
movl (%rsi), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
cmpl $0x13, %eax
ja 0x4df6e
movq %rsi, %r14
addq $0x8, %rsi
leaq 0x7ef93(%rip), %rcx # 0xccc10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x28(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rax)
cmpb $0x1, 0x80(%r14)
jne 0x4dcd3
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x88(%r14), %rsi
movq 0x90(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, -0x18(%r15)
movb $0x0, 0xc8(%rsp)
cmpb $0x1, 0xa8(%r14)
jne 0x4dd17
leaq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xb0(%r14), %rsi
movq 0xb8(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0xc8(%rsp)
movsd 0x28(%rsp), %xmm1
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x78(%rsp), %xmm0
movaps %xmm0, 0x120(%rsp)
mulsd 0x7eeb1(%rip), %xmm1 # 0xccbf0
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x14130
movapd %xmm0, 0x110(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x6807b(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
movapd %xmm0, 0x100(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0xf0(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14130
movapd 0x120(%rsp), %xmm1
mulsd %xmm1, %xmm0
movapd 0x110(%rsp), %xmm2
unpcklpd 0x10(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x100(%rsp), %xmm3
unpcklpd 0xf0(%rsp), %xmm3 # xmm3 = xmm3[0],mem[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm3, %xmm1
movupd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
cmpb $0x1, 0xc8(%rsp)
jne 0x4de1d
leaq 0xe0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4de15
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0xc8(%rsp)
cmpb $0x1, 0xa0(%rsp)
je 0x4df3d
jmp 0x4df5e
leaq 0x28(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rax)
cmpb $0x1, 0x80(%r14)
jne 0x4de81
leaq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x88(%r14), %rsi
movq 0x90(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, -0x18(%r15)
movb $0x1, %al
jmp 0x4de83
xorl %eax, %eax
movb $0x0, 0xc8(%rsp)
cmpb $0x1, 0xa8(%r14)
jne 0x4df19
leaq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0xb0(%r14), %rsi
movq 0xb8(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0xc8(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movq 0xd0(%rsp), %rdi
cmpq %r15, %rdi
je 0x4df08
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0xc8(%rsp)
movb 0xa0(%rsp), %al
jmp 0x4df39
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
testb $0x1, %al
je 0x4df5e
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4df5e
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rax
addq $0x130, %rsp # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x4e9bb
movq %rax, %rbx
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
setne %cl
andb -0x18(%rax), %cl
cmpb $0x1, %cl
je 0x4dfaf
jmp 0x4dfba
movq %rax, %rbx
leaq 0xb8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
setne %cl
testb %cl, -0x18(%rax)
je 0x4dfba
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/geom.cpp
|
ear::toPolarPosition(ear::CartesianPosition)
|
PolarPosition toPolarPosition(CartesianPosition position) {
auto cart_array = toCartesianVector3d(position);
return PolarPosition(azimuth(cart_array), elevation(cart_array),
distance(cart_array));
}
|
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movaps 0x50(%rsp), %xmm2
movaps %xmm2, 0x10(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movaps %xmm2, %xmm1
unpckhpd %xmm2, %xmm1 # xmm1 = xmm1[1],xmm2[1]
movaps %xmm1, 0x20(%rsp)
movaps %xmm2, %xmm0
callq 0x140d0
movaps %xmm0, 0x30(%rsp)
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
callq 0x14190
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x140d0
movapd 0x10(%rsp), %xmm2
mulpd %xmm2, %xmm2
movapd %xmm2, %xmm1
unpckhpd %xmm2, %xmm1 # xmm1 = xmm1[1],xmm2[1]
addsd %xmm2, %xmm1
movsd 0x8(%rsp), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm1, %xmm2
movapd 0x30(%rsp), %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
mulpd 0x7eb9d(%rip), %xmm1 # 0xccc00
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
movupd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
|
/ebu[P]libear/src/common/geom.cpp
|
ear::toCartesianVector3d(ear::PolarPosition)
|
Eigen::Vector3d toCartesianVector3d(PolarPosition position) {
return cart(position.azimuth, position.elevation, position.distance);
}
|
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd 0x70(%rsp), %xmm1
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x80(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
mulsd 0x7eb44(%rip), %xmm1 # 0xccbf0
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x67d11(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14130
movapd 0x50(%rsp), %xmm1
mulsd %xmm1, %xmm0
movapd 0x40(%rsp), %xmm2
unpcklpd 0x10(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm3
unpcklpd 0x20(%rsp), %xmm3 # xmm3 = xmm3[0],mem[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm3, %xmm1
movupd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
|
/ebu[P]libear/src/common/geom.cpp
|
ear::toCartesianPosition(ear::PolarPosition)
|
CartesianPosition toCartesianPosition(PolarPosition position) {
auto cartesian = toCartesianVector3d(position);
return CartesianPosition(cartesian[0], cartesian[1], cartesian[2]);
}
|
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movsd 0x70(%rsp), %xmm1
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x80(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
mulsd 0x7ea75(%rip), %xmm1 # 0xccbf0
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x67c42(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14130
movapd 0x50(%rsp), %xmm1
mulsd %xmm1, %xmm0
movapd 0x40(%rsp), %xmm2
unpcklpd 0x10(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm3
unpcklpd 0x20(%rsp), %xmm3 # xmm3 = xmm3[0],mem[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm3, %xmm1
movupd %xmm1, (%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
|
/ebu[P]libear/src/common/geom.cpp
|
ear::toNormalisedVector3d(ear::PolarPosition)
|
Eigen::Vector3d toNormalisedVector3d(PolarPosition position) {
return cart(position.azimuth, position.elevation, 1.0);
}
|
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movsd 0x60(%rsp), %xmm0
movsd 0x68(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0x7e9b4(%rip), %xmm0 # 0xccbf0
movsd %xmm0, 0x10(%rsp)
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x67b85(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14130
movapd 0x40(%rsp), %xmm1
unpcklpd 0x10(%rsp), %xmm1 # xmm1 = xmm1[0],mem[0]
movapd 0x30(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
mulpd %xmm1, %xmm2
movupd %xmm2, (%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
|
/ebu[P]libear/src/common/geom.cpp
|
ear::toPositionsMatrix(std::vector<ear::PolarPosition, std::allocator<ear::PolarPosition>> const&)
|
Eigen::MatrixXd toPositionsMatrix(
const std::vector<PolarPosition>& positions) {
Eigen::MatrixXd ret(positions.size(), 3);
for (unsigned int i = 0; i < positions.size(); ++i) {
ret.row(i) = toCartesianVector3d(positions[i]);
}
return ret;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $-0x18, %rsi
jle 0x4e4bd
movq %rdi, %rbx
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
movq %rsi, %rdx
imulq %r15, %rdx
movl $0x3, %ecx
callq 0x3e05a
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x4e451
xorl %r12d, %r12d
leaq (%r12,%r12,2), %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rax,%rcx,8), %xmm0
movaps %xmm0, 0x50(%rsp)
movsd (%rax,%rcx,8), %xmm0
mulsd 0x7e8a4(%rip), %xmm0 # 0xccbf0
movsd %xmm0, 0x10(%rsp)
callq 0x14130
movapd %xmm0, 0x40(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x67a75(%rip), %xmm0 # 0xb5de0
movsd %xmm0, 0x8(%rsp)
callq 0x14b60
movapd %xmm0, 0x30(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14b60
movaps %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x14130
movapd 0x50(%rsp), %xmm1
mulsd %xmm1, %xmm0
movapd 0x40(%rsp), %xmm2
unpcklpd 0x10(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd 0x30(%rsp), %xmm3
unpcklpd 0x20(%rsp), %xmm3 # xmm3 = xmm3[0],mem[0]
mulpd %xmm2, %xmm3
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm3, %xmm1
movapd %xmm1, 0x60(%rsp)
movsd %xmm0, 0x70(%rsp)
movq (%rbx), %rax
movq 0x10(%rbx), %rdx
testq %rax, %rax
sete %cl
testq %rdx, %rdx
setns %sil
orb %cl, %sil
je 0x4e49e
movq 0x8(%rbx), %rcx
cmpq %r12, %rcx
jle 0x4e47f
cmpq $0x3, %rdx
jne 0x4e460
movl %r12d, %edx
shlq $0x3, %rdx
addq %rdx, %rax
shlq $0x3, %rcx
xorl %edx, %edx
movsd 0x60(%rsp,%rdx,8), %xmm0
movsd %xmm0, (%rax)
incq %rdx
addq %rcx, %rax
cmpq $0x3, %rdx
jne 0x4e41d
incl %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r15, %rcx
cmpq %r12, %rcx
ja 0x4e324
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x64a2f(%rip), %rdi # 0xb2e96
leaq 0x64a91(%rip), %rsi # 0xb2eff
leaq 0x6837a(%rip), %rcx # 0xb67ef
movl $0x106, %edx # imm = 0x106
callq 0x143c0
leaq 0x62c94(%rip), %rdi # 0xb111a
leaq 0x62d34(%rip), %rsi # 0xb11c1
leaq 0x682b6(%rip), %rcx # 0xb674a
movl $0x7a, %edx
callq 0x143c0
leaq 0x62e34(%rip), %rdi # 0xb12d9
leaq 0x62ed7(%rip), %rsi # 0xb1383
leaq 0x643cc(%rip), %rcx # 0xb287f
movl $0xb2, %edx
callq 0x143c0
leaq 0x626cc(%rip), %rdi # 0xb0b90
leaq 0x62854(%rip), %rsi # 0xb0d1f
leaq 0x628be(%rip), %rcx # 0xb0d90
movl $0x115, %edx # imm = 0x115
callq 0x143c0
movq %rax, %r14
movq (%rbx), %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/geom.cpp
|
void Eigen::internal::call_dense_assignment_loop<Eigen::Transpose<Eigen::Matrix<double, 3, 1, 0, 3, 1>>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_quotient_op<double, double>, Eigen::PartialReduxExpr<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::member_sum<double, double>, 0> const, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 1, -1, 1, 1, -1> const> const>, Eigen::internal::assign_op<double, double>>(Eigen::Transpose<Eigen::Matrix<double, 3, 1, 0, 3, 1>>&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_quotient_op<double, double>, Eigen::PartialReduxExpr<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::internal::member_sum<double, double>, 0> const, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, 1, -1, 1, 1, -1> const> const> const&, Eigen::internal::assign_op<double, double> const&)
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void resize_if_allowed(DstXprType &dst, const SrcXprType& src, const internal::assign_op<T1,T2> &/*func*/)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if(((dst.rows()!=dstRows) || (dst.cols()!=dstCols)))
dst.resize(dstRows, dstCols);
eigen_assert(dst.rows() == dstRows && dst.cols() == dstCols);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpq $0x3, 0x20(%rsi)
jne 0x4ec72
movq 0x8(%rsi), %r12
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%rdi), %r13
xorl %ebp, %ebp
leaq 0x50(%rsp), %rbx
leaq 0xf(%rsp), %r14
leaq 0x18(%rsp), %r15
movq (%r12), %rdx
movq 0x8(%r12), %rax
movq %rax, %rcx
imulq %rbp, %rcx
leaq (%rdx,%rcx,8), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
testq %rdx, %rdx
sete %dl
testq %rax, %rax
setns %sil
orb %dl, %sil
je 0x4ec34
movq %r12, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq %rbp, 0x40(%rsp)
movq %rax, 0x48(%rsp)
cmpq %rbp, 0x10(%r12)
jle 0x4ec15
testq %rax, %rax
je 0x4ebe8
jle 0x4ec53
movq %rcx, 0x50(%rsp)
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4ec92
jmp 0x4ebec
xorpd %xmm0, %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, (%r13,%rbp,8)
incq %rbp
cmpq $0x3, %rbp
jne 0x4eb70
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x624fe(%rip), %rdi # 0xb111a
leaq 0x6259e(%rip), %rsi # 0xb11c1
leaq 0x62b13(%rip), %rcx # 0xb173d
movl $0x7a, %edx
callq 0x143c0
leaq 0x6269e(%rip), %rdi # 0xb12d9
leaq 0x62741(%rip), %rsi # 0xb1383
leaq 0x62bae(%rip), %rcx # 0xb17f7
movl $0xb2, %edx
callq 0x143c0
leaq 0x61cd2(%rip), %rdi # 0xb092c
leaq 0x61d0f(%rip), %rsi # 0xb0970
leaq 0x7e335(%rip), %rcx # 0xccf9d
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
leaq 0x61f17(%rip), %rdi # 0xb0b90
leaq 0x6209f(%rip), %rsi # 0xb0d1f
leaq 0x6725d(%rip), %rcx # 0xb5ee4
movl $0x115, %edx # imm = 0x115
callq 0x143c0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h
|
double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true>>, 3, 0>::run<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true>>(Eigen::internal::redux_evaluator<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true>> const&, Eigen::internal::scalar_sum_op<double, double> const&, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const&)
|
static Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
{
const Index size = xpr.size();
const Index packetSize = redux_traits<Func, Evaluator>::PacketSize;
const int packetAlignment = unpacket_traits<PacketScalar>::alignment;
enum {
alignment0 = (bool(Evaluator::Flags & DirectAccessBit) && bool(packet_traits<Scalar>::AlignedOnScalar)) ? int(packetAlignment) : int(Unaligned),
alignment = EIGEN_PLAIN_ENUM_MAX(alignment0, Evaluator::Alignment)
};
const Index alignedStart = internal::first_default_aligned(xpr);
const Index alignedSize2 = ((size-alignedStart)/(2*packetSize))*(2*packetSize);
const Index alignedSize = ((size-alignedStart)/(packetSize))*(packetSize);
const Index alignedEnd2 = alignedStart + alignedSize2;
const Index alignedEnd = alignedStart + alignedSize;
Scalar res;
if(alignedSize)
{
PacketScalar packet_res0 = eval.template packet<alignment,PacketScalar>(alignedStart);
if(alignedSize>packetSize) // we have at least two packets to partly unroll the loop
{
PacketScalar packet_res1 = eval.template packet<alignment,PacketScalar>(alignedStart+packetSize);
for(Index index = alignedStart + 2*packetSize; index < alignedEnd2; index += 2*packetSize)
{
packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment,PacketScalar>(index));
packet_res1 = func.packetOp(packet_res1, eval.template packet<alignment,PacketScalar>(index+packetSize));
}
packet_res0 = func.packetOp(packet_res0,packet_res1);
if(alignedEnd>alignedEnd2)
packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment,PacketScalar>(alignedEnd2));
}
res = func.predux(packet_res0);
for(Index index = 0; index < alignedStart; ++index)
res = func(res,eval.coeff(index));
for(Index index = alignedEnd; index < size; ++index)
res = func(res,eval.coeff(index));
}
else // too small to vectorize anything.
// since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
{
res = eval.coeff(0);
for(Index index = 1; index < size; ++index)
res = func(res,eval.coeff(index));
}
return res;
}
|
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
movq %rax, %rsi
testb $0x7, %cl
jne 0x4ecb1
shrl $0x3, %ecx
andl $0x1, %ecx
cmpq %rax, %rcx
cmovgeq %rax, %rcx
movq %rcx, %rsi
movq %rax, %r9
subq %rsi, %r9
leaq 0x3(%r9), %r8
testq %r9, %r9
cmovnsq %r9, %r8
leaq 0x1(%r9), %rdx
movq (%rdi), %rcx
cmpq $0x3, %rdx
jae 0x4ecf4
movsd (%rcx), %xmm0
cmpq $0x2, %rax
jl 0x4ed8f
movl $0x1, %edx
addsd (%rcx,%rdx,8), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x4ece2
jmp 0x4ed8f
movq %r9, %rdx
shrq $0x3f, %rdx
addq %r9, %rdx
andq $-0x2, %rdx
movupd (%rcx,%rsi,8), %xmm1
cmpq $0x4, %r9
jl 0x4ed5d
andq $-0x4, %r8
leaq (%r8,%rsi), %rdi
movupd 0x10(%rcx,%rsi,8), %xmm0
cmpq $0x8, %r9
jb 0x4ed43
leaq 0x4(%rsi), %r9
movupd (%rcx,%r9,8), %xmm2
addpd %xmm2, %xmm1
movupd 0x10(%rcx,%r9,8), %xmm2
addpd %xmm2, %xmm0
addq $0x4, %r9
cmpq %rdi, %r9
jl 0x4ed25
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
addpd %xmm2, %xmm1
cmpq %r8, %rdx
jle 0x4ed5d
movupd (%rcx,%rdi,8), %xmm0
addpd %xmm0, %xmm1
addq %rsi, %rdx
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
testq %rsi, %rsi
jle 0x4ed8a
xorl %edi, %edi
addsd (%rcx,%rdi,8), %xmm0
incq %rdi
cmpq %rdi, %rsi
jne 0x4ed73
jmp 0x4ed8a
addsd (%rcx,%rdx,8), %xmm0
incq %rdx
cmpq %rax, %rdx
jl 0x4ed82
retq
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/Redux.h
|
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Product<Eigen::CwiseBinaryOp<Eigen::internal::scalar_difference_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Replicate<Eigen::Transpose<Eigen::Matrix<double, 3, 1, 0, 3, 1>>, -1, 1> const>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, 1>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Product<Eigen::CwiseBinaryOp<Eigen::internal::scalar_difference_op<double, double>, Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Replicate<Eigen::Transpose<Eigen::Matrix<double, 3, 1, 0, 3, 1>>, -1, 1> const>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, 1> const&, Eigen::internal::assign_op<double, double> const&)
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
// we need to resize the destination after the source evaluator has been created.
resize_if_allowed(dst, src, func);
DstEvaluatorType dstEvaluator(dst);
typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
dense_assignment_loop<Kernel>::run(kernel);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq (%rsi), %r13
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rbx
movq 0x28(%rsi), %r12
cmpq %rbx, 0x8(%rdi)
je 0x4edd7
testq %rbx, %rbx
js 0x4ee69
movl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x4476c
cmpq %rbx, 0x8(%r14)
jne 0x4ee88
testq %rbx, %rbx
jle 0x4ee40
movq (%r14), %rax
movq (%r13), %rcx
movq 0x8(%r13), %rdx
leaq (%rcx,%rdx,8), %rsi
shlq $0x3, %rdx
xorl %edi, %edi
cmpq %rbx, %rdi
je 0x4ee4a
movsd (%rcx,%rdi,8), %xmm0
subsd (%r15), %xmm0
mulsd (%r12), %xmm0
movq %rsi, %r8
xorl %r9d, %r9d
movsd (%r8), %xmm1
subsd 0x8(%r15,%r9,8), %xmm1
mulsd 0x8(%r12,%r9,8), %xmm1
addsd %xmm1, %xmm0
incq %r9
addq %rdx, %r8
cmpq $0x2, %r9
jne 0x4ee0c
movsd %xmm0, (%rax,%rdi,8)
incq %rdi
addq $0x8, %rsi
cmpq %rbx, %rdi
jne 0x4edf1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x622c9(%rip), %rdi # 0xb111a
leaq 0x62369(%rip), %rsi # 0xb11c1
leaq 0x7e599(%rip), %rcx # 0xcd3f8
movl $0x7a, %edx
callq 0x143c0
leaq 0x61d20(%rip), %rdi # 0xb0b90
leaq 0x61ea8(%rip), %rsi # 0xb0d1f
leaq 0x67546(%rip), %rcx # 0xb63c4
movl $0x115, %edx # imm = 0x115
callq 0x143c0
leaq 0x620d7(%rip), %rdi # 0xb0f66
leaq 0x620ff(%rip), %rsi # 0xb0f95
leaq 0x7e3b1(%rip), %rcx # 0xcd24e
movl $0x2fd, %edx # imm = 0x2FD
callq 0x143c0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h
|
ear::RegionHandler::RegionHandler(Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
|
RegionHandler::RegionHandler(Eigen::VectorXi outputChannels,
Eigen::MatrixXd positions)
: _outputChannels(outputChannels), _positions(positions){}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %r15
leaq 0xbcb3e(%rip), %rax # 0x10b9f8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x55da6
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x44694
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::RegionHandler::handleRemap(Eigen::Matrix<double, 3, 1, 0, 3, 1>, int) const
|
boost::optional<Eigen::VectorXd> RegionHandler::handleRemap(
Eigen::Vector3d position, int numberOfChannels) const {
boost::optional<Eigen::VectorXd> pv = handle(position);
if (pv) {
Eigen::VectorXd _pv = pv.get();
Eigen::VectorXd out = Eigen::VectorXd::Zero(numberOfChannels);
for (int i = 0; i < _pv.size(); ++i) {
out(_outputChannels(i)) = _pv(i);
}
return out;
}
return boost::none;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movups (%rdx), %xmm0
leaq 0x50(%rsp), %rax
movaps %xmm0, (%rax)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq (%rsi), %rcx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq *(%rcx)
movb (%r15), %al
cmpb $0x1, %al
jne 0x4efc2
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x55e5e
movslq %ebp, %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x48(%rsp)
testl %eax, %eax
js 0x4f043
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
callq 0x4b398
movq 0x18(%rsp), %rax
testq %rax, %rax
jle 0x4efc7
movq 0x10(%rsp), %rdi
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdx
movq (%rsp), %rsi
xorl %r8d, %r8d
testq %rdx, %rdx
cmovleq %r8, %rdx
cmpq %r8, %rdx
je 0x4f005
movslq (%rcx,%r8,4), %r10
testq %r10, %r10
js 0x4f024
movq 0x8(%rsp), %r9
cmpq %r10, %r9
jle 0x4f024
movsd (%rdi,%r8,8), %xmm0
movsd %xmm0, (%rsi,%r10,8)
incq %r8
cmpq %r8, %rax
jne 0x4ef90
jmp 0x4efd1
movb $0x0, (%rbx)
jmp 0x4efe9
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r9, 0x10(%rbx)
movb $0x1, (%rbx)
callq 0x14720
movb 0x20(%rsp), %al
testb $0x1, %al
je 0x4eff7
movq 0x28(%rsp), %rdi
callq 0x14720
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64767(%rip), %rdi # 0xb3773
leaq 0x6477d(%rip), %rsi # 0xb3790
leaq 0x7e992(%rip), %rcx # 0xcd9ac
movl $0xb5, %edx
callq 0x143c0
leaq 0x64748(%rip), %rdi # 0xb3773
leaq 0x6475e(%rip), %rsi # 0xb3790
leaq 0x6570e(%rip), %rcx # 0xb4747
movl $0x1ab, %edx # imm = 0x1AB
callq 0x143c0
leaq 0x62c82(%rip), %rdi # 0xb1ccc
leaq 0x62d10(%rip), %rsi # 0xb1d61
leaq 0x67e6d(%rip), %rcx # 0xb6ec5
movl $0x4a, %edx
callq 0x143c0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x14720
jmp 0x4f074
movq %rax, %rbx
cmpb $0x1, 0x20(%rsp)
jne 0x4f085
movq 0x28(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::Triplet::Triplet(Eigen::Matrix<int, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 3, 0, 3, 3>)
|
Triplet::Triplet(Eigen::Vector3i outputChannels, Eigen::Matrix3d positions)
: RegionHandler(outputChannels, positions) {
_basis = _positions.inverse();
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl $0xc, %edi
callq 0x147f0
testq %rax, %rax
je 0x4f1e0
movq %rax, %r15
movq %rax, 0x30(%rsp)
movq $0x3, 0x38(%rsp)
movl 0x8(%r12), %eax
movl %eax, 0x8(%r15)
movq (%r12), %rax
movq %rax, (%r15)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x9, %esi
movl $0x3, %edx
movl $0x3, %ecx
callq 0x3e05a
cmpq $0x3, 0x18(%rsp)
jne 0x4f11f
cmpq $0x3, 0x20(%rsp)
je 0x4f150
leaq 0x10(%rsp), %rdi
movl $0x9, %esi
movl $0x3, %edx
movl $0x3, %ecx
callq 0x3e05a
cmpq $0x3, 0x18(%rsp)
jne 0x4f22d
cmpq $0x3, 0x20(%rsp)
jne 0x4f22d
movq $-0x2, %rcx
movq 0x10(%rsp), %rax
movups 0x10(%r14,%rcx,8), %xmm0
movaps %xmm0, 0x10(%rax,%rcx,8)
addq $0x2, %rcx
cmpq $0x6, %rcx
jb 0x4f15c
movsd 0x40(%r14), %xmm0
movsd %xmm0, 0x40(%rax)
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4eea8
movq 0x10(%rsp), %rdi
callq 0x14720
movq 0x30(%rsp), %rdi
callq 0x14720
leaq 0xbc877(%rip), %rax # 0x10ba20
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x20(%rbx), %rax
cmpq 0x28(%rbx), %rax
jne 0x4f20e
leaq 0x18(%rbx), %rax
leaq 0x30(%rbx), %rdi
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xf(%rsp), %rdx
callq 0x55f16
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x14290
movq 0xc0d47(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xc0d99(%rip), %rsi # 0x10ff98
movq 0xc0d02(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0x7e906(%rip), %rdi # 0xcdb1b
leaq 0x7e910(%rip), %rsi # 0xcdb2c
leaq 0x7e974(%rip), %rcx # 0xcdb97
movl $0x15f, %edx # imm = 0x15F
callq 0x143c0
leaq 0x61d32(%rip), %rdi # 0xb0f66
leaq 0x61d5a(%rip), %rsi # 0xb0f95
leaq 0x7e7f9(%rip), %rcx # 0xcda3b
movl $0x2fd, %edx # imm = 0x2FD
callq 0x143c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x559c0
jmp 0x4f282
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x14720
movq 0x30(%rsp), %r15
jmp 0x4f27a
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x14720
movq %r15, %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::Triplet::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) const
|
boost::optional<Eigen::VectorXd> Triplet::handle(
Eigen::Vector3d position) const {
Eigen::VectorXd pv = position.transpose() * _basis;
double epsilon = -1e-11;
if (pv(0) >= epsilon && pv(1) >= epsilon && pv(2) >= epsilon) {
pv /= pv.norm();
return pv.cwiseMax(0.0).cwiseMin(1.0).eval();
}
return boost::none;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movl $0x18, %edi
callq 0x147f0
testb $0xf, %al
jne 0x4f50a
testq %rax, %rax
je 0x4f529
addq $0x30, %r14
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq $0x3, 0x8(%r12)
leaq 0x38(%rsp), %rdi
movq %r12, (%rdi)
leaq 0x20(%rsp), %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
leaq 0xf(%rsp), %rdx
callq 0x5a4c8
movq 0x18(%rsp), %rax
testq %rax, %rax
jle 0x4f4eb
movq 0x10(%rsp), %rdi
movsd (%rdi), %xmm0
ucomisd 0x7e2ca(%rip), %xmm0 # 0xcd5e0
jb 0x4f34a
cmpq $0x1, %rax
je 0x4f4eb
movsd 0x8(%rdi), %xmm0
ucomisd 0x7e2b1(%rip), %xmm0 # 0xcd5e0
jb 0x4f34a
cmpq $0x2, %rax
jbe 0x4f4eb
movsd 0x10(%rdi), %xmm0
ucomisd 0x7e298(%rip), %xmm0 # 0xcd5e0
jae 0x4f361
movb $0x0, (%rbx)
callq 0x14720
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38(%rsp), %rdx
movq %r12, (%rdx)
leaq 0x20(%rsp), %rax
movq %rdi, 0x8(%rax)
leaq 0xf(%rsp), %rsi
movq %rax, %rdi
callq 0x5a5e2
movq 0x18(%rsp), %rax
testq %rax, %rax
js 0x4f557
movq %xmm0, %xmm0 # xmm0 = xmm0[0],zero
sqrtpd %xmm0, %xmm0
movq 0x10(%rsp), %rcx
movabsq $0x7ffffffffffffffe, %rdx # imm = 0x7FFFFFFFFFFFFFFE
andq %rax, %rdx
cmpq $0x2, %rax
jb 0x4f3ce
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
xorl %esi, %esi
movapd (%rcx,%rsi,8), %xmm2
divpd %xmm1, %xmm2
movapd %xmm2, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jb 0x4f3b7
cmpq %rax, %rdx
jge 0x4f3e9
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4f3d3
movq 0x18(%rsp), %r14
testq %r14, %r14
js 0x4f557
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq 0x10(%rsp), %r15
je 0x4f45f
movabsq $0x1ffffffffffffffe, %r12 # imm = 0x1FFFFFFFFFFFFFFE
leaq 0x1(%r12), %rax
cmpq %rax, %r14
ja 0x4f576
leaq (,%r14,8), %rdi
callq 0x147f0
cmpq $0x1, %r14
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x4f50a
testq %rax, %rax
je 0x4f576
movq %rax, 0x20(%rsp)
movq %r14, 0x28(%rsp)
cmpq $0x1, %r14
jne 0x4f466
xorl %r12d, %r12d
jmp 0x4f496
xorl %r12d, %r12d
xorl %eax, %eax
jmp 0x4f496
andq %r14, %r12
xorl %ecx, %ecx
movapd 0x7e1dd(%rip), %xmm0 # 0xcd650
movaps (%r15,%rcx,8), %xmm1
xorpd %xmm2, %xmm2
maxpd %xmm1, %xmm2
movapd %xmm0, %xmm1
minpd %xmm2, %xmm1
movapd %xmm1, (%rax,%rcx,8)
addq $0x2, %rcx
cmpq %r12, %rcx
jb 0x4f473
cmpq %r14, %r12
jge 0x4f4c3
movsd 0x5fb65(%rip), %xmm0 # 0xaf008
xorpd %xmm1, %xmm1
maxsd (%r15,%r12,8), %xmm1
movapd %xmm0, %xmm2
minsd %xmm1, %xmm2
movsd %xmm2, (%rax,%r12,8)
incq %r12
cmpq %r12, %r14
jne 0x4f4a3
movb $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x55e5e
movb $0x1, (%rbx)
movq 0x20(%rsp), %rdi
callq 0x14720
movq 0x10(%rsp), %rdi
jmp 0x4f34d
leaq 0x64281(%rip), %rdi # 0xb3773
leaq 0x64297(%rip), %rsi # 0xb3790
leaq 0x65247(%rip), %rcx # 0xb4747
movl $0x1ab, %edx # imm = 0x1AB
callq 0x143c0
leaq 0x618fa(%rip), %rdi # 0xb0e0b
leaq 0x619ae(%rip), %rsi # 0xb0ec6
leaq 0x61a14(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xc09fe(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xc0a50(%rip), %rsi # 0x10ff98
movq 0xc09b9(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0x6276e(%rip), %rdi # 0xb1ccc
leaq 0x627fc(%rip), %rsi # 0xb1d61
leaq 0x67959(%rip), %rcx # 0xb6ec5
movl $0x4a, %edx
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xc09b1(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xc0a03(%rip), %rsi # 0x10ff98
movq 0xc096c(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0x14720
jmp 0x4f5ba
jmp 0x4f5b7
jmp 0x4f5b7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::VirtualNgon::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) const
|
boost::optional<Eigen::VectorXd> VirtualNgon::handle(
Eigen::Vector3d position) const {
for (const auto& region : _regions) {
boost::optional<Eigen::VectorXd> pv = region->handleRemap(
position, static_cast<int>(_centreDownmix.size() + 1));
if (pv) {
// downmix the last channel containing the virtual centre
// speaker into the real speakers, and renormalise
Eigen::VectorXd _pv = pv.get();
_pv = _pv.head(_pv.size() - 1) + _centreDownmix * _pv.tail(1);
_pv /= _pv.norm();
return _pv;
}
}
return boost::none;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, 0x20(%rsp)
movq 0x58(%rsi), %rbp
movq 0x60(%rsi), %rbx
cmpq %rbx, %rbp
je 0x4fc70
movq %rdx, %r15
movq %rsi, %r14
leaq 0x28(%rsp), %r12
leaq 0x50(%rsp), %r13
movq (%rbp), %rsi
movq 0x10(%r15), %rax
movq %rax, 0x60(%rsp)
movdqu (%r15), %xmm0
movdqa %xmm0, 0x50(%rsp)
movl 0x50(%r14), %ecx
incl %ecx
movq %r12, %rdi
movq %r13, %rdx
callq 0x4eef6
cmpb $0x1, 0x28(%rsp)
je 0x4fc8d
addq $0x8, %rbp
cmpq %rbx, %rbp
jne 0x4fc37
movq 0x20(%rsp), %rbx
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x55e5e
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
testq %rcx, %rcx
sete %dl
testq %rax, %rax
setg %sil
orb %dl, %sil
je 0x4fe2a
testq %rax, %rax
jle 0x4fe49
leaq 0x48(%r14), %rdx
leaq -0x1(%rax), %rsi
leaq (%rcx,%rsi,8), %rdi
movq %rcx, 0x68(%rsp)
movq %rsi, 0x70(%rsp)
movq %r15, 0x80(%rsp)
movq $0x0, 0x88(%rsp)
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rdi, 0xa8(%rsp)
movq $0x1, 0xb0(%rsp)
movq %r15, 0xc0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rax, 0xd8(%rsp)
cmpq 0x50(%r14), %rsi
jne 0x4fe68
leaq 0x10(%rsp), %r14
leaq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x5a841
movq %r14, 0x40(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x4fdf6
movq 0x20(%rsp), %rbx
jle 0x4fe87
movq 0x10(%rsp), %rax
leaq 0x68(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq 0xf(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x5a5e2
movq 0x18(%rsp), %rax
testq %rax, %rax
js 0x4fea6
movq %xmm0, %xmm0 # xmm0 = xmm0[0],zero
sqrtpd %xmm0, %xmm0
movq 0x10(%rsp), %rcx
movabsq $0x7ffffffffffffffe, %rdx # imm = 0x7FFFFFFFFFFFFFFE
andq %rax, %rdx
cmpq $0x2, %rax
jb 0x4fdd9
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
xorl %esi, %esi
movapd (%rcx,%rsi,8), %xmm2
divpd %xmm1, %xmm2
movapd %xmm2, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jb 0x4fdc2
cmpq %rax, %rdx
jge 0x4fdfb
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x4fdde
jmp 0x4fdfb
movq 0x20(%rsp), %rbx
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movb $0x1, (%rbx)
cmpb $0x1, 0x28(%rsp)
jne 0x4fc78
movq 0x30(%rsp), %rdi
callq 0x14720
jmp 0x4fc78
leaq 0x614a8(%rip), %rdi # 0xb12d9
leaq 0x6154b(%rip), %rsi # 0xb1383
leaq 0x829f7(%rip), %rcx # 0xd2836
movl $0xb2, %edx
callq 0x143c0
leaq 0x6617d(%rip), %rdi # 0xb5fcd
leaq 0x6136a(%rip), %rsi # 0xb11c1
leaq 0x8291c(%rip), %rcx # 0xd277a
movl $0x93, %edx
callq 0x143c0
leaq 0x61632(%rip), %rdi # 0xb14a1
leaq 0x61664(%rip), %rsi # 0xb14da
leaq 0x82a6b(%rip), %rcx # 0xd28e8
movl $0x74, %edx
callq 0x143c0
leaq 0x60a9e(%rip), %rdi # 0xb092c
leaq 0x60adb(%rip), %rsi # 0xb0970
leaq 0x824c8(%rip), %rcx # 0xd2364
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
leaq 0x61e1f(%rip), %rdi # 0xb1ccc
leaq 0x61ead(%rip), %rsi # 0xb1d61
leaq 0x6700a(%rip), %rcx # 0xb6ec5
movl $0x4a, %edx
callq 0x143c0
jmp 0x4fec7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x14720
jmp 0x4fed9
movq %rax, %rbx
cmpb $0x1, 0x28(%rsp)
jne 0x4feea
movq 0x30(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::QuadRegion::QuadRegion(Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
|
QuadRegion::QuadRegion(Eigen::VectorXi outputChannels,
Eigen::MatrixXd positions)
: RegionHandler(outputChannels, positions) {
_order = ngonVertexOrder(positions);
Eigen::MatrixXd reorderedPositions =
positions(_order, Eigen::indexing::all);
Eigen::MatrixXd reorderedAndShiftedPositions =
reorderedPositions(Eigen::Vector4i{1, 2, 3, 0}, Eigen::indexing::all);
_polyBasisX = _calcPolyBasis(reorderedPositions);
_polyBasisY = _calcPolyBasis(reorderedAndShiftedPositions);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x55da6
leaq 0xe0(%rsp), %rdi
movq %r14, %rsi
callq 0x44694
leaq 0x28(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
movq %rbx, %rdi
callq 0x4eea8
movq 0xe0(%rsp), %rdi
callq 0x14720
movq 0x28(%rsp), %rdi
callq 0x14720
leaq 0xbbb1d(%rip), %rax # 0x10ba70
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
leaq 0xc8(%rsp), %rdi
movq %r14, %rsi
callq 0x44694
leaq 0x50(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x4d5fe
leaq 0x30(%rbx), %r15
movq 0x30(%rbx), %rdi
leaq 0x50(%rsp), %r12
movq (%r12), %rax
movq %rax, 0x30(%rbx)
movq %rdi, (%r12)
movq 0x38(%rbx), %rax
movq 0x8(%r12), %rcx
movq %rcx, 0x38(%rbx)
movq %rax, 0x8(%r12)
callq 0x14720
movq 0xc8(%rsp), %rdi
callq 0x14720
leaq 0x7d719(%rip), %rcx # 0xcd6e0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x54ba4
leaq 0x38(%rsp), %r14
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x5abfc
movq 0x58(%rsp), %rdi
callq 0x14720
movaps 0x7d668(%rip), %xmm0 # 0xcd660
movaps %xmm0, 0x60(%rsp)
movq 0x48(%rsp), %rcx
movq %r14, 0x50(%rsp)
movq %rcx, 0x70(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rcx, %rcx
je 0x50051
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq $0x4, %rax
jl 0x50129
testq %rcx, %rcx
js 0x50157
movq %rcx, %rax
shrq $0x3d, %rax
jne 0x50129
leaq (,%rcx,4), %rsi
leaq 0x10(%rsp), %rdi
movl $0x4, %edx
callq 0x3e05a
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x5ae6b
leaq 0xb0(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x44694
leaq 0x50(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
callq 0x50208
leaq 0x40(%rbx), %rdi
leaq 0x50(%rsp), %rsi
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
movq 0xb0(%rsp), %rdi
callq 0x14720
leaq 0x98(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x44694
leaq 0x50(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq 0x50208
addq $0x88, %rbx
leaq 0x50(%rsp), %rsi
movl $0x9, %ecx
movq %rbx, %rdi
rep movsq (%rsi), %es:(%rdi)
movq 0x98(%rsp), %rdi
callq 0x14720
movq 0x10(%rsp), %rdi
callq 0x14720
movq 0x38(%rsp), %rdi
callq 0x14720
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x14290
movq 0xbfdfe(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xbfe50(%rip), %rsi # 0x10ff98
movq 0xbfdb9(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0x60a32(%rip), %rdi # 0xb0b90
leaq 0x60bba(%rip), %rsi # 0xb0d1f
leaq 0x60c24(%rip), %rcx # 0xb0d90
movl $0x115, %edx # imm = 0x115
callq 0x143c0
movq %rax, %r14
movq 0x98(%rsp), %rdi
jmp 0x50190
jmp 0x501d8
movq %rax, %r14
movq 0xb0(%rsp), %rdi
callq 0x14720
jmp 0x501db
jmp 0x501d8
movq %rax, %r14
movq 0x58(%rsp), %rdi
jmp 0x501ea
jmp 0x501b2
movq %rax, %r14
movq 0xc8(%rsp), %rdi
jmp 0x501ea
movq %rax, %r14
jmp 0x501ef
movq %rax, %r14
movq 0xe0(%rsp), %rdi
callq 0x14720
jmp 0x501cc
movq %rax, %r14
movq 0x28(%rsp), %rdi
callq 0x14720
jmp 0x50200
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x14720
movq 0x38(%rsp), %rdi
callq 0x14720
movq 0x30(%rbx), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x559c0
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::QuadRegion::_calcPolyBasis(Eigen::Matrix<double, -1, -1, 0, -1, -1>)
|
Eigen::Matrix3d QuadRegion::_calcPolyBasis(Eigen::MatrixXd positions) {
Eigen::Vector3d a = positions.row(0);
Eigen::Vector3d b = positions.row(1);
Eigen::Vector3d c = positions.row(2);
Eigen::Vector3d d = positions.row(3);
Eigen::Matrix3d polyBasis;
polyBasis << //
(b - a).cross(c - d), //
a.cross(c - d) + (b - a).cross(d), //
a.cross(d);
return polyBasis.transpose();
}
|
pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x10(%rdx), %rsi
testq %rax, %rax
sete %cl
testq %rsi, %rsi
setns %dil
orb %cl, %dil
je 0x505c4
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
jle 0x505a5
cmpq $0x3, %rsi
jne 0x505e3
cmpq $0x1, %rcx
je 0x505a5
cmpq $0x2, %rcx
jbe 0x505a5
cmpq $0x3, %rcx
je 0x505a5
movsd (%rax), %xmm11
movsd (%rax,%rcx,8), %xmm12
movq %rcx, %rdx
shlq $0x4, %rdx
movsd (%rax,%rdx), %xmm13
movsd 0x8(%rax), %xmm0
movsd 0x8(%rax,%rcx,8), %xmm1
movsd 0x8(%rax,%rdx), %xmm2
unpcklpd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
movsd 0x18(%rax), %xmm14
movsd 0x10(%rax,%rcx,8), %xmm3
movsd 0x18(%rax,%rcx,8), %xmm5
movsd 0x18(%rax,%rdx), %xmm2
movsd 0x10(%rax,%rdx), %xmm4
movhpd 0x10(%rax), %xmm4 # xmm4 = xmm4[0],mem[0]
movapd %xmm12, %xmm15
unpcklpd %xmm13, %xmm15 # xmm15 = xmm15[0],xmm13[0]
subpd %xmm15, %xmm1
movapd %xmm5, 0x90(%rsp)
subsd %xmm5, %xmm3
movapd %xmm2, 0x20(%rsp)
movapd %xmm2, %xmm5
unpcklpd %xmm14, %xmm5 # xmm5 = xmm5[0],xmm14[0]
movapd %xmm5, 0x80(%rsp)
subpd %xmm5, %xmm4
subsd %xmm11, %xmm0
movapd %xmm1, %xmm5
shufpd $0x1, %xmm0, %xmm5 # xmm5 = xmm5[1],xmm0[0]
movapd %xmm4, %xmm6
unpckhpd %xmm4, %xmm6 # xmm6 = xmm6[1],xmm4[1]
movapd %xmm6, %xmm7
mulsd %xmm1, %xmm7
movapd %xmm0, %xmm9
mulsd %xmm3, %xmm9
subsd %xmm7, %xmm9
movapd %xmm3, %xmm8
unpcklpd %xmm4, %xmm8 # xmm8 = xmm8[0],xmm4[0]
movapd %xmm8, %xmm7
mulpd %xmm5, %xmm7
movapd %xmm1, %xmm10
mulpd %xmm4, %xmm10
subpd %xmm7, %xmm10
movapd 0x5fd4a(%rip), %xmm2 # 0xb0090
movapd %xmm1, %xmm7
xorpd %xmm2, %xmm7
xorpd %xmm2, %xmm5
movapd %xmm10, 0xa0(%rsp)
movsd %xmm9, 0xb0(%rsp)
leaq 0x38(%rsp), %r14
movq %r14, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x1, 0x10(%rsp)
movq $0x3, 0x18(%rsp)
movl %r14d, %eax
shrl $0x3, %eax
andl $0x1, %eax
jne 0x503af
movapd 0xa0(%rsp), %xmm10
movapd %xmm10, 0x38(%rsp)
movsd %xmm9, 0x48(%rsp)
jmp 0x503ca
movlpd %xmm10, 0x38(%rsp)
shll $0x3, %eax
movupd 0xa0(%rsp,%rax), %xmm9
movapd %xmm9, 0x38(%rsp,%rax)
unpcklpd %xmm11, %xmm13 # xmm13 = xmm13[0],xmm11[0]
movapd %xmm13, 0xc0(%rsp)
mulsd %xmm12, %xmm6
mulsd %xmm11, %xmm3
subsd %xmm6, %xmm3
mulpd %xmm13, %xmm8
mulpd %xmm15, %xmm4
subpd %xmm8, %xmm4
leaq 0x150(%rsp), %rax
movapd %xmm4, (%rax)
movsd %xmm3, 0x10(%rax)
movapd 0x90(%rsp), %xmm3
movapd %xmm3, %xmm2
unpcklpd 0x20(%rsp), %xmm2 # xmm2 = xmm2[0],mem[0]
movapd %xmm2, 0x20(%rsp)
mulpd %xmm2, %xmm5
mulsd %xmm14, %xmm7
mulsd %xmm3, %xmm0
addsd %xmm7, %xmm0
mulpd 0x80(%rsp), %xmm1
addpd %xmm5, %xmm1
leaq 0x130(%rsp), %rcx
movapd %xmm1, (%rcx)
movsd %xmm0, 0x10(%rcx)
leaq 0x170(%rsp), %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
movq %rsp, %rdi
movapd %xmm11, 0x100(%rsp)
movapd %xmm12, 0xd0(%rsp)
movapd %xmm14, 0xe0(%rsp)
movapd %xmm15, 0xf0(%rsp)
callq 0x54d98
movapd 0x5fbfa(%rip), %xmm0 # 0xb0090
movapd 0xc0(%rsp), %xmm2
xorpd %xmm0, %xmm2
movapd 0xd0(%rsp), %xmm1
xorpd %xmm0, %xmm1
movapd 0x20(%rsp), %xmm0
mulpd %xmm2, %xmm0
movapd 0xe0(%rsp), %xmm2
mulsd %xmm1, %xmm2
movapd 0x100(%rsp), %xmm1
mulsd 0x90(%rsp), %xmm1
addsd %xmm2, %xmm1
movapd 0xf0(%rsp), %xmm2
mulpd 0x80(%rsp), %xmm2
addpd %xmm0, %xmm2
leaq 0x110(%rsp), %rsi
movapd %xmm2, (%rsi)
movsd %xmm1, 0x10(%rsi)
movq %rax, %rdi
callq 0x54e9a
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
cmpq $0x3, %rax
jne 0x50643
cmpq $0x3, 0x10(%rsp)
jne 0x50643
cmpq %rbx, %r14
je 0x50602
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x10(%rbx)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x18(%rbx)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x20(%rbx)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x28(%rbx)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x30(%rbx)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x38(%rbx)
movsd 0x78(%rsp), %xmm0
movsd %xmm0, 0x40(%rbx)
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r14
retq
leaq 0x60b6e(%rip), %rdi # 0xb111a
leaq 0x60c0e(%rip), %rsi # 0xb11c1
leaq 0x66190(%rip), %rcx # 0xb674a
movl $0x7a, %edx
callq 0x143c0
leaq 0x60d0e(%rip), %rdi # 0xb12d9
leaq 0x60db1(%rip), %rsi # 0xb1383
leaq 0x622a6(%rip), %rcx # 0xb287f
movl $0xb2, %edx
callq 0x143c0
leaq 0x605a6(%rip), %rdi # 0xb0b90
leaq 0x6072e(%rip), %rsi # 0xb0d1f
leaq 0x658ec(%rip), %rcx # 0xb5ee4
movl $0x115, %edx # imm = 0x115
callq 0x143c0
leaq 0x63acf(%rip), %rdi # 0xb40d8
leaq 0x63bdb(%rip), %rsi # 0xb41eb
leaq 0x840f6(%rip), %rcx # 0xd470d
movl $0x1b6, %edx # imm = 0x1B6
callq 0x143c0
jmp 0x50623
movq 0x18(%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq $0x3, %rcx
jne 0x50643
cmpq $0x3, 0x10(%rsp)
jne 0x50643
movq %rax, %rdi
callq 0x14ad0
leaq 0x66469(%rip), %rdi # 0xb6ab3
leaq 0x6590a(%rip), %rsi # 0xb5f5b
leaq 0x664f9(%rip), %rcx # 0xb6b51
movl $0x7c, %edx
callq 0x143c0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::QuadRegion::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) const
|
boost::optional<Eigen::VectorXd> QuadRegion::handle(
Eigen::Vector3d position) const {
boost::optional<double> x = _pan(position, _polyBasisX);
boost::optional<double> y = _pan(position, _polyBasisY);
if (x == boost::none || y == boost::none) {
return boost::none;
}
Eigen::VectorXd pvs = Eigen::Vector4d::Zero();
pvs(_order) << (1 - x.get()) * (1 - y.get()), x.get() * (1 - y.get()),
x.get() * y.get(), (1 - x.get()) * y.get();
if ((pvs.transpose() * _positions) * position <= 0) {
return boost::none;
}
pvs /= pvs.norm();
return pvs;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rcx
leaq 0xb0(%rsp), %rax
movq %rcx, 0x10(%rax)
movups (%rdx), %xmm0
movaps %xmm0, (%rax)
addq $0x40, %rsi
leaq 0x110(%rsp), %rdx
movl $0x9, %ecx
movq %rdx, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %rax, %rsi
callq 0x50b0a
movl %eax, %ebp
movsd %xmm0, 0x10(%rsp)
movupd (%r14), %xmm0
leaq 0x90(%rsp), %rax
movapd %xmm0, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
leaq 0x88(%r15), %rsi
leaq 0xc8(%rsp), %rdx
movl $0x9, %ecx
movq %rdx, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %rax, %rsi
callq 0x50b0a
testb $0x1, %bpl
je 0x509ac
testb $0x1, %al
je 0x509ac
movsd %xmm0, 0x18(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movl $0x20, %edi
callq 0x147f0
testb $0xf, %al
jne 0x509d3
testq %rax, %rax
je 0x509f2
movq %rsp, %r12
movq %rax, (%r12)
movq $0x4, 0x8(%r12)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rax)
movapd %xmm0, (%rax)
leaq 0x30(%r15), %rdx
leaq 0x58(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x54c0a
movq %r13, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movl $0x1, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x68(%rsp)
movsd 0x10(%rsp), %xmm2
jle 0x50a20
movsd 0x5e870(%rip), %xmm0 # 0xaf008
movapd %xmm0, %xmm1
subsd %xmm2, %xmm1
subsd 0x18(%rsp), %xmm0
movsd %xmm1, 0x78(%rsp)
mulsd %xmm0, %xmm1
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rcx
movq (%rax), %rax
movslq (%rcx), %rcx
movsd %xmm1, (%rax,%rcx,8)
mulsd %xmm2, %xmm0
leaq 0x48(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x54c68
movsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
leaq 0x88(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rax, %rdi
callq 0x54c68
movsd 0x78(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
leaq 0x80(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rax, %rdi
callq 0x54c68
movq 0x38(%rsp), %rax
addq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x50a3f
cmpq $0x1, 0x30(%rsp)
jne 0x50a3f
movq 0x60(%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rax
cmpq 0x20(%r15), %rax
jne 0x50a5e
cmpq $0x3, 0x28(%r15)
jne 0x50a75
addq $0x18, %r15
leaq 0x50(%rsp), %rax
movq %rax, -0x8(%rax)
leaq 0x58(%rsp), %rsi
movq %r12, (%rsi)
movq %r15, 0x8(%rsi)
movq %r14, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
callq 0x5afcc
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rdi
movupd (%rcx), %xmm0
movupd (%rax), %xmm1
mulpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x10(%rcx), %xmm1
mulsd 0x10(%rax), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
callq 0x14720
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x48(%rsp), %rax
xorpd %xmm0, %xmm0
ucomisd (%rax), %xmm0
jae 0x509b1
movq %r12, 0x58(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x5098c
jle 0x50a94
movq (%rsp), %rax
leaq 0x20(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq 0x48(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x5a5e2
movq 0x8(%rsp), %rax
testq %rax, %rax
js 0x50ab3
movq %xmm0, %xmm0 # xmm0 = xmm0[0],zero
sqrtpd %xmm0, %xmm0
movq (%rsp), %rcx
movabsq $0x7ffffffffffffffe, %rdx # imm = 0x7FFFFFFFFFFFFFFE
andq %rax, %rdx
cmpq $0x2, %rax
jb 0x50971
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
xorl %esi, %esi
movapd (%rcx,%rsi,8), %xmm2
divpd %xmm1, %xmm2
movapd %xmm2, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jb 0x5095a
cmpq %rax, %rdx
jge 0x5098c
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x50976
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movb $0x1, %al
xorl %edi, %edi
jmp 0x509b7
movb $0x0, (%rbx)
jmp 0x509be
movq (%rsp), %rdi
xorl %eax, %eax
movb %al, (%rbx)
callq 0x14720
movq %rbx, %rax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x60431(%rip), %rdi # 0xb0e0b
leaq 0x604e5(%rip), %rsi # 0xb0ec6
leaq 0x6054b(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xbf535(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xbf587(%rip), %rsi # 0x10ff98
movq 0xbf4f0(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0x81bf5(%rip), %rdi # 0xd261c
leaq 0x6552d(%rip), %rsi # 0xb5f5b
leaq 0x82ce6(%rip), %rcx # 0xd371b
movl $0x25, %edx
callq 0x143c0
leaq 0x6606d(%rip), %rdi # 0xb6ab3
leaq 0x6550e(%rip), %rsi # 0xb5f5b
leaq 0x82df0(%rip), %rcx # 0xd3844
movl $0x7c, %edx
callq 0x143c0
leaq 0x610a8(%rip), %rdi # 0xb1b0d
leaq 0x6112d(%rip), %rsi # 0xb1b99
leaq 0x83017(%rip), %rcx # 0xd3a8a
jmp 0x50a8a
leaq 0x61091(%rip), %rdi # 0xb1b0d
leaq 0x61116(%rip), %rsi # 0xb1b99
leaq 0x830e9(%rip), %rcx # 0xd3b73
movl $0x62, %edx
callq 0x143c0
leaq 0x5fe91(%rip), %rdi # 0xb092c
leaq 0x5fece(%rip), %rsi # 0xb0970
leaq 0x818bb(%rip), %rcx # 0xd2364
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
leaq 0x61212(%rip), %rdi # 0xb1ccc
leaq 0x612a0(%rip), %rsi # 0xb1d61
leaq 0x663fd(%rip), %rcx # 0xb6ec5
movl $0x4a, %edx
callq 0x143c0
jmp 0x50af5
jmp 0x50af5
jmp 0x50ada
jmp 0x50ada
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x54d5e
movq 0x60(%rsp), %rdi
callq 0x14720
jmp 0x50af8
jmp 0x50af5
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::QuadRegion::_pan(Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 3, 0, 3, 3>) const
|
std::pair<std::vector<Channel>, Eigen::MatrixXd> extraPosVerticalNominal(
Layout layout) {
std::vector<Channel> extraChannels;
Eigen::MatrixXd downmix = Eigen::MatrixXd::Identity(
layout.channels().size(), layout.channels().size());
Layout midLayerLayout;
std::copy_if(layout.channels().begin(), layout.channels().end(),
std::back_inserter(midLayerLayout.channels()), [](Channel c) {
return -10 <= c.polarPositionNominal().elevation &&
c.polarPositionNominal().elevation <= 10;
});
auto layers = {std::make_tuple(-30.0, -70.0, -10.0),
std::make_tuple(30.0, 10.0, 70.0)};
double layerNominalElevation, layerLowerBound, layerUpperBound;
for (const auto& layer : layers) {
std::tie(layerNominalElevation, layerLowerBound, layerUpperBound) = layer;
Layout currentLayerLayout;
std::copy_if(
layout.channels().begin(), layout.channels().end(),
std::back_inserter(currentLayerLayout.channels()), [&](Channel c) {
return layerLowerBound <= c.polarPositionNominal().elevation &&
c.polarPositionNominal().elevation <= layerUpperBound;
});
// for each loudspeaker in the mid layer that has an azimuth greater
// than az_limit, add a virtual speaker directly above/below it at the
// elevation of the current layer, which is downmixed directly to the
// mid layer loudspeaker. az_limit is set to the range of azimuths in
// the current layer, with some space added to prevent fast vertical
// source movements when sources move horizontally. If there are no
// channels on this layer then a copy of all mid layer speakers is
// made.
double azimuthLimit = 0.0;
double layerRealElevation = 0.0;
if (currentLayerLayout.channels().size() != 0) {
double azimuthRange = std::numeric_limits<double>::min();
for (const auto& channel : currentLayerLayout.channels()) {
if (azimuthRange < std::abs(channel.polarPositionNominal().azimuth)) {
azimuthRange = std::abs(channel.polarPositionNominal().azimuth);
}
}
azimuthLimit = azimuthRange + 40.0;
layerRealElevation =
std::accumulate(currentLayerLayout.channels().begin(),
currentLayerLayout.channels().end(), 0.0,
[&](double sum, const Channel& c) -> double {
return sum + c.polarPosition().elevation;
}) /
static_cast<double>(currentLayerLayout.channels().size());
} else {
layerRealElevation = layerNominalElevation;
}
double epsilon = 1e-5;
for (const auto& midChannel : midLayerLayout.channels()) {
if (std::abs(midChannel.polarPosition().azimuth) >=
azimuthLimit - epsilon) {
extraChannels.push_back(Channel(
"extra",
PolarPosition(midChannel.polarPosition().azimuth,
layerRealElevation, 1.0),
PolarPosition(midChannel.polarPositionNominal().azimuth,
layerNominalElevation, 1.0)
));
Eigen::VectorXd downmixRow =
Eigen::VectorXd::Zero(layout.channels().size());
auto names = layout.channelNames();
int midChannelIndex = static_cast<int>(std::distance(
names.begin(),
std::find(names.begin(), names.end(), midChannel.name())));
downmixRow(midChannelIndex) = 1.0;
downmix.conservativeResize(downmix.rows() + 1, Eigen::NoChange);
downmix.row(downmix.rows() - 1) = downmixRow;
}
}
}
return std::make_pair(extraChannels, downmix);
}
|
pushq %rbx
subq $0x30, %rsp
movupd (%rsi), %xmm1
movupd 0x8(%rsi), %xmm2
movapd %xmm1, %xmm0
unpcklpd %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movupd (%rdx), %xmm3
mulpd %xmm0, %xmm3
movupd 0x18(%rdx), %xmm4
movapd %xmm2, %xmm0
movsd 0x28(%rdx), %xmm5
movhpd 0x40(%rdx), %xmm5 # xmm5 = xmm5[0],mem[0]
mulpd %xmm2, %xmm5
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
mulpd %xmm4, %xmm2
addpd %xmm3, %xmm2
movupd 0x30(%rdx), %xmm3
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
mulpd %xmm3, %xmm0
addpd %xmm2, %xmm0
mulsd 0x10(%rdx), %xmm1
movapd %xmm5, %xmm2
unpckhpd %xmm5, %xmm2 # xmm2 = xmm2[1],xmm5[1]
addsd %xmm5, %xmm2
addsd %xmm1, %xmm2
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x50c11
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
cmpq %rax, %rdi
je 0x50bbe
movsd 0x7ca4e(%rip), %xmm2 # 0xcd5e8
movsd 0x7ca4e(%rip), %xmm1 # 0xcd5f0
movq %rdi, %rcx
movsd (%rcx), %xmm0
ucomisd %xmm2, %xmm0
jbe 0x50bb5
ucomisd %xmm0, %xmm1
ja 0x50bd4
addq $0x8, %rcx
cmpq %rax, %rcx
jne 0x50ba5
testq %rdi, %rdi
je 0x50bd0
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
xorl %eax, %eax
jmp 0x50c0b
movsd 0x5e42c(%rip), %xmm2 # 0xaf008
minsd %xmm0, %xmm2
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm0
andnpd %xmm2, %xmm0
testq %rdi, %rdi
je 0x50c09
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
movapd %xmm0, (%rsp)
callq 0x145f0
movapd (%rsp), %xmm0
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
retq
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::PolarPointSourcePanner::PolarPointSourcePanner(std::vector<std::unique_ptr<ear::RegionHandler, std::default_delete<ear::RegionHandler>>, std::allocator<std::unique_ptr<ear::RegionHandler, std::default_delete<ear::RegionHandler>>>>, boost::optional<int>)
|
PolarPointSourcePanner::PolarPointSourcePanner(
std::vector<std::unique_ptr<RegionHandler>> regions,
boost::optional<int> numberOfChannels)
: _regions(std::move(regions)) {
if (!numberOfChannels) {
_numberOfOutputChannels = _numberOfRequiredChannels();
} else {
_numberOfOutputChannels = numberOfChannels.get();
ear_assert(_numberOfOutputChannels >= _numberOfRequiredChannels(),
"not enough output channels in PolarPointSourcePanner");
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xbacc9(%rip), %rax # 0x10ba98
addq $0x10, %rax
movq %rax, (%rdi)
movups (%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
testb $0x1, %r14b
je 0x50e61
shrq $0x20, %r14
movl %r14d, 0x20(%rbx)
movq %rbx, %rdi
callq 0x50ebe
cmpl %r14d, %eax
jle 0x50e6c
movl $0x10, %edi
callq 0x14290
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7c9bd(%rip), %rsi # 0xcd7e9
leaq 0x7c9ea(%rip), %rdx # 0xcd81d
movq %rsp, %rdi
callq 0x37fd8
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fb0
xorl %ebp, %ebp
leaq 0xba836(%rip), %rsi # 0x10b688
movq 0xbf11f(%rip), %rdx # 0x10ff78
movq %r14, %rdi
callq 0x14a60
movq %rbx, %rdi
callq 0x50ebe
movl %eax, 0x20(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x50e92
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x50e9c
jmp 0x50ea9
movq %rax, %r15
movq %r14, %rdi
callq 0x14460
jmp 0x50ea9
movq %rax, %r15
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x54b50
movq %r15, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::PointSourcePannerDownmix::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
|
boost::optional<Eigen::VectorXd> PointSourcePannerDownmix::handle(
Eigen::Vector3d position) {
boost::optional<Eigen::VectorXd> pv = _psp->handle(position);
if (pv) {
Eigen::VectorXd _pv = pv.get();
_pv = _downmix.transpose() * _pv;
_pv /= _pv.norm();
return _pv;
}
return boost::none;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
movq 0x10(%rdx), %rcx
leaq 0x50(%rsp), %rax
movq %rcx, 0x10(%rax)
movdqu (%rdx), %xmm0
movdqa %xmm0, (%rax)
movq (%rsi), %rcx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
callq *(%rcx)
movb (%r15), %al
cmpb $0x1, %al
jne 0x51254
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x55e5e
movq 0x20(%r14), %rax
cmpq 0x10(%rsp), %rax
jne 0x51272
addq $0x18, %r14
leaq 0x40(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, 0x8(%rsi)
leaq 0x30(%rsp), %rdx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x5b71d
movq %r15, 0x30(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x51239
jle 0x51291
movq 0x8(%rsp), %rax
leaq 0x40(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq 0x7(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x5a5e2
movq 0x10(%rsp), %rax
testq %rax, %rax
js 0x512b0
movq %xmm0, %xmm0 # xmm0 = xmm0[0],zero
sqrtpd %xmm0, %xmm0
movq 0x8(%rsp), %rcx
movabsq $0x7ffffffffffffffe, %rdx # imm = 0x7FFFFFFFFFFFFFFE
andq %rax, %rdx
cmpq $0x2, %rax
jb 0x5121e
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
xorl %esi, %esi
movapd (%rcx,%rsi,8), %xmm2
divpd %xmm1, %xmm2
movapd %xmm2, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jb 0x51207
cmpq %rax, %rdx
jge 0x51239
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x51223
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movb $0x1, (%rbx)
movb 0x18(%rsp), %al
jmp 0x51257
movb $0x0, (%rbx)
testb $0x1, %al
je 0x51265
movq 0x20(%rsp), %rdi
callq 0x14720
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x60894(%rip), %rdi # 0xb1b0d
leaq 0x60919(%rip), %rsi # 0xb1b99
leaq 0x83688(%rip), %rcx # 0xd490f
movl $0x62, %edx
callq 0x143c0
leaq 0x5f694(%rip), %rdi # 0xb092c
leaq 0x5f6d1(%rip), %rsi # 0xb0970
leaq 0x810be(%rip), %rcx # 0xd2364
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
leaq 0x60a15(%rip), %rdi # 0xb1ccc
leaq 0x60aa3(%rip), %rsi # 0xb1d61
leaq 0x65c00(%rip), %rcx # 0xb6ec5
movl $0x4a, %edx
callq 0x143c0
jmp 0x512d1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x14720
jmp 0x512e3
movq %rax, %rbx
cmpb $0x1, 0x18(%rsp)
jne 0x512f4
movq 0x20(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::extraPosVerticalNominal(ear::Layout)
|
std::pair<std::vector<Channel>, Eigen::MatrixXd> extraPosVerticalNominal(
Layout layout) {
std::vector<Channel> extraChannels;
Eigen::MatrixXd downmix = Eigen::MatrixXd::Identity(
layout.channels().size(), layout.channels().size());
Layout midLayerLayout;
std::copy_if(layout.channels().begin(), layout.channels().end(),
std::back_inserter(midLayerLayout.channels()), [](Channel c) {
return -10 <= c.polarPositionNominal().elevation &&
c.polarPositionNominal().elevation <= 10;
});
auto layers = {std::make_tuple(-30.0, -70.0, -10.0),
std::make_tuple(30.0, 10.0, 70.0)};
double layerNominalElevation, layerLowerBound, layerUpperBound;
for (const auto& layer : layers) {
std::tie(layerNominalElevation, layerLowerBound, layerUpperBound) = layer;
Layout currentLayerLayout;
std::copy_if(
layout.channels().begin(), layout.channels().end(),
std::back_inserter(currentLayerLayout.channels()), [&](Channel c) {
return layerLowerBound <= c.polarPositionNominal().elevation &&
c.polarPositionNominal().elevation <= layerUpperBound;
});
// for each loudspeaker in the mid layer that has an azimuth greater
// than az_limit, add a virtual speaker directly above/below it at the
// elevation of the current layer, which is downmixed directly to the
// mid layer loudspeaker. az_limit is set to the range of azimuths in
// the current layer, with some space added to prevent fast vertical
// source movements when sources move horizontally. If there are no
// channels on this layer then a copy of all mid layer speakers is
// made.
double azimuthLimit = 0.0;
double layerRealElevation = 0.0;
if (currentLayerLayout.channels().size() != 0) {
double azimuthRange = std::numeric_limits<double>::min();
for (const auto& channel : currentLayerLayout.channels()) {
if (azimuthRange < std::abs(channel.polarPositionNominal().azimuth)) {
azimuthRange = std::abs(channel.polarPositionNominal().azimuth);
}
}
azimuthLimit = azimuthRange + 40.0;
layerRealElevation =
std::accumulate(currentLayerLayout.channels().begin(),
currentLayerLayout.channels().end(), 0.0,
[&](double sum, const Channel& c) -> double {
return sum + c.polarPosition().elevation;
}) /
static_cast<double>(currentLayerLayout.channels().size());
} else {
layerRealElevation = layerNominalElevation;
}
double epsilon = 1e-5;
for (const auto& midChannel : midLayerLayout.channels()) {
if (std::abs(midChannel.polarPosition().azimuth) >=
azimuthLimit - epsilon) {
extraChannels.push_back(Channel(
"extra",
PolarPosition(midChannel.polarPosition().azimuth,
layerRealElevation, 1.0),
PolarPosition(midChannel.polarPositionNominal().azimuth,
layerNominalElevation, 1.0)
));
Eigen::VectorXd downmixRow =
Eigen::VectorXd::Zero(layout.channels().size());
auto names = layout.channelNames();
int midChannelIndex = static_cast<int>(std::distance(
names.begin(),
std::find(names.begin(), names.end(), midChannel.name())));
downmixRow(midChannelIndex) = 1.0;
downmix.conservativeResize(downmix.rows() + 1, Eigen::NoChange);
downmix.row(downmix.rows() - 1) = downmixRow;
}
}
}
return std::make_pair(extraChannels, downmix);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, %r12
xorpd %xmm0, %xmm0
movapd %xmm0, 0x150(%rsp)
movq $0x0, 0x160(%rsp)
movq %rsi, 0x28(%rsp)
movq %rsi, %rdi
callq 0x45100
movq (%rax), %r14
movq 0x8(%rax), %rbx
movq 0x28(%rsp), %rdi
callq 0x45100
subq %r14, %rbx
sarq $0x4, %rbx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rdx, %rbx
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x4, %rcx
imulq %rdx, %rcx
movq %rbx, 0x60(%rsp)
movq %rcx, 0x68(%rsp)
orq %rbx, %rcx
js 0x51f5f
leaq 0xf0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x5bcc0
leaq 0x1c0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x88952(%rip), %rdx # 0xd9cf9
leaq 0x1b0(%rsp), %rdi
movq %rdx, %rsi
callq 0x37fd8
xorpd %xmm0, %xmm0
movapd %xmm0, 0x1f0(%rsp)
movq $0x0, 0x200(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x46e48
leaq 0x320(%rsp), %r15
movb $0x0, -0x8(%r15)
leaq 0x60(%rsp), %rsi
movq %r15, %rdi
callq 0x38a4c
movb $0x1, -0x8(%r15)
leaq 0x368(%rsp), %rdi
leaq 0x1b0(%rsp), %rsi
leaq 0x1f0(%rsp), %rdx
leaq 0x318(%rsp), %rcx
callq 0x4502c
cmpb $0x1, 0x318(%rsp)
jne 0x51438
movq %r15, %rdi
callq 0x36866
movb $0x0, 0x318(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x36866
leaq 0x1f0(%rsp), %rdi
callq 0x36ef6
movq 0x1b0(%rsp), %rdi
cmpq %r14, %rdi
je 0x5146c
movq 0x1c0(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x28(%rsp), %rdi
callq 0x45100
movq (%rax), %rbx
movq 0x28(%rsp), %rdi
callq 0x45100
movq 0x8(%rax), %rbp
leaq 0x368(%rsp), %rdi
callq 0x45100
movq %rax, 0x30(%rsp)
movq %r12, 0x170(%rsp)
cmpq %rbp, %rbx
je 0x51615
leaq 0x70(%rsp), %r14
leaq 0x60(%rsp), %r12
leaq 0x2a8(%rsp), %r13
movq %r14, 0x60(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x36894
movq 0x30(%rbx), %rax
movq %rax, 0x20(%r14)
movupd 0x20(%rbx), %xmm0
movupd %xmm0, 0x10(%r14)
movb $0x0, 0x98(%rsp)
cmpb $0x1, 0x38(%rbx)
jne 0x5150f
movq 0x50(%rbx), %rax
movq %rax, 0x40(%r14)
movupd 0x40(%rbx), %xmm0
movupd %xmm0, 0x30(%r14)
movb $0x1, 0x98(%rsp)
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x58(%rbx)
jne 0x51530
movupd 0x60(%rbx), %xmm0
movupd %xmm0, 0x50(%r14)
movb $0x1, 0xb8(%rsp)
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0x70(%rbx)
jne 0x51551
movupd 0x78(%rbx), %xmm0
movupd %xmm0, 0x68(%r14)
movb $0x1, 0xd0(%rsp)
movb 0x88(%rbx), %al
movb %al, 0xe8(%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x44c0a
movsd 0x2b0(%rsp), %xmm0
ucomisd 0x7c086(%rip), %xmm0 # 0xcd600
jae 0x51581
xorl %r15d, %r15d
jmp 0x515a6
leaq 0x260(%rsp), %rdi
movq %r12, %rsi
callq 0x44c0a
movsd 0x64887(%rip), %xmm0 # 0xb5e20
ucomisd 0x268(%rsp), %xmm0
setae %r15b
cmpb $0x1, 0xd0(%rsp)
jne 0x515b8
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x515ca
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x515dc
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x515f3
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %r15b, %r15b
je 0x51605
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x462e0
addq $0x90, %rbx
cmpq %rbp, %rbx
jne 0x514bc
movaps 0x7c054(%rip), %xmm0 # 0xcd670
movaps %xmm0, 0x260(%rsp)
movaps 0x7c055(%rip), %xmm0 # 0xcd680
movaps %xmm0, 0x270(%rsp)
movapd 0x7c055(%rip), %xmm0 # 0xcd690
movapd %xmm0, 0x280(%rsp)
leaq 0x70(%rsp), %r14
leaq 0x60(%rsp), %r12
leaq 0x2a8(%rsp), %rbx
xorl %eax, %eax
movsd 0x270(%rsp,%rax), %xmm0
movsd %xmm0, 0x108(%rsp)
movsd 0x260(%rsp,%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rax, 0x178(%rsp)
movsd 0x268(%rsp,%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x110(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0x8864a(%rip), %rdx # 0xd9cf9
movq %rdx, %rsi
callq 0x37fd8
xorpd %xmm0, %xmm0
movapd %xmm0, 0x1d0(%rsp)
movq $0x0, 0x1e0(%rsp)
movq %r12, %rdi
callq 0x46e48
movb $0x0, 0x228(%rsp)
leaq 0x230(%rsp), %rdi
movq %r12, %rsi
callq 0x38a4c
movb $0x1, 0x228(%rsp)
movq %rbx, %rdi
leaq 0x110(%rsp), %rsi
leaq 0x1d0(%rsp), %rdx
leaq 0x228(%rsp), %rcx
callq 0x4502c
cmpb $0x1, 0x228(%rsp)
jne 0x51737
leaq 0x230(%rsp), %rdi
callq 0x36866
movb $0x0, 0x228(%rsp)
movq %r12, %rdi
callq 0x36866
leaq 0x1d0(%rsp), %rdi
callq 0x36ef6
movq 0x110(%rsp), %rdi
leaq 0x120(%rsp), %rax
cmpq %rax, %rdi
je 0x51771
movq 0x120(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x28(%rsp), %rdi
callq 0x45100
movq (%rax), %rbp
movq 0x28(%rsp), %rdi
callq 0x45100
movq 0x8(%rax), %r15
leaq 0x2a8(%rsp), %rdi
callq 0x45100
cmpq %r15, %rbp
je 0x518f8
movq %rax, %rbx
movq %r14, 0x60(%rsp)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x36894
movq 0x30(%rbp), %rax
movq %rax, 0x20(%r14)
movupd 0x20(%rbp), %xmm0
movupd %xmm0, 0x10(%r14)
movb $0x0, 0x98(%rsp)
cmpb $0x1, 0x38(%rbp)
jne 0x517f9
movq 0x50(%rbp), %rax
movq %rax, 0x40(%r14)
movupd 0x40(%rbp), %xmm0
movupd %xmm0, 0x30(%r14)
movb $0x1, 0x98(%rsp)
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x58(%rbp)
jne 0x5181a
movupd 0x60(%rbp), %xmm0
movupd %xmm0, 0x50(%r14)
movb $0x1, 0xb8(%rsp)
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0x70(%rbp)
jne 0x5183b
movupd 0x78(%rbp), %xmm0
movupd %xmm0, 0x68(%r14)
movb $0x1, 0xd0(%rsp)
movb 0x88(%rbp), %al
movb %al, 0xe8(%rsp)
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x44c0a
movsd 0x48(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jae 0x51868
xorl %r13d, %r13d
jmp 0x5188b
leaq 0x290(%rsp), %rdi
movq %r12, %rsi
callq 0x44c0a
movsd 0x20(%rsp), %xmm0
ucomisd 0x298(%rsp), %xmm0
setae %r13b
cmpb $0x1, 0xd0(%rsp)
jne 0x5189d
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x518af
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x518c1
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x518d8
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %r13b, %r13b
je 0x518e8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x462e0
addq $0x90, %rbp
cmpq %r15, %rbp
jne 0x517a5
leaq 0x2a8(%rsp), %r13
movq %r13, %rdi
callq 0x45100
movq 0x8(%rax), %rcx
movsd 0x108(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x7bce5(%rip), %xmm0 # 0xcd608
movapd %xmm0, 0x30(%rsp)
cmpq (%rax), %rcx
je 0x51a73
movq %r13, %rdi
callq 0x45100
movq (%rax), %rbx
movq 0x8(%rax), %r15
movsd 0x7bcc7(%rip), %xmm0 # 0xcd610
movapd %xmm0, 0x30(%rsp)
cmpq %r15, %rbx
je 0x519ca
movsd 0x7bcbc(%rip), %xmm0 # 0xcd618
movapd %xmm0, 0x30(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x44c0a
movsd 0x60(%rsp), %xmm0
andpd 0x5d6e5(%rip), %xmm0 # 0xaf060
ucomisd 0x30(%rsp), %xmm0
jbe 0x519a2
movq %r12, %rdi
movq %rbx, %rsi
callq 0x44c0a
movsd 0x60(%rsp), %xmm0
andpd 0x5d6c4(%rip), %xmm0 # 0xaf060
movapd %xmm0, 0x30(%rsp)
addq $0x90, %rbx
cmpq %r15, %rbx
jne 0x51962
movapd 0x30(%rsp), %xmm0
addsd 0x7bc64(%rip), %xmm0 # 0xcd620
addsd 0x7bc44(%rip), %xmm0 # 0xcd608
movapd %xmm0, 0x30(%rsp)
movq %r13, %rdi
callq 0x45100
movq (%rax), %rbx
movq %r13, %rdi
callq 0x45100
movq 0x8(%rax), %r15
xorpd %xmm0, %xmm0
cmpq %r15, %rbx
je 0x51a1b
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x44bf6
movsd 0x20(%rsp), %xmm0
addsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
addq $0x90, %rbx
cmpq %r15, %rbx
jne 0x519f0
jmp 0x51a21
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
callq 0x45100
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x4, %rcx
movabsq $-0x71c71c71c71c71c7, %rax # imm = 0x8E38E38E38E38E39
imulq %rax, %rcx
movq %rcx, %xmm0
punpckldq 0x7bc51(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x7bc59(%rip), %xmm0 # 0xcd6b0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x368(%rsp), %rdi
callq 0x45100
movq (%rax), %rbp
movq 0x8(%rax), %r15
cmpq %r15, %rbp
je 0x51db7
movq %r12, %rdi
movq %rbp, %rsi
callq 0x44bf6
movsd 0x60(%rsp), %xmm0
andpd 0x5d5b7(%rip), %xmm0 # 0xaf060
ucomisd 0x30(%rsp), %xmm0
jb 0x51dab
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x7bd53(%rip), %rsi # 0xcd81e
leaq 0x7bd51(%rip), %rdx # 0xcd823
callq 0x37fd8
leaq 0x290(%rsp), %rdi
movq %rbp, %rsi
callq 0x44bf6
movsd 0x290(%rsp), %xmm0
movsd %xmm0, 0x210(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x218(%rsp)
movabsq $0x3ff0000000000000, %rbx # imm = 0x3FF0000000000000
movq %rbx, 0x220(%rsp)
leaq 0x350(%rsp), %rdi
movq %rbp, %rsi
callq 0x44c0a
movsd 0x350(%rsp), %xmm0
movsd %xmm0, 0x138(%rsp)
movsd 0x108(%rsp), %xmm0
movsd %xmm0, 0x140(%rsp)
movq %rbx, 0x148(%rsp)
movb $0x1, 0x130(%rsp)
xorl %eax, %eax
movb %al, 0x198(%rsp)
movb %al, 0x180(%rsp)
movq 0x220(%rsp), %rax
movq %rax, 0x10(%rsp)
movupd 0x210(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq %r12, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x130(%rsp), %rdx
leaq 0x198(%rsp), %rcx
leaq 0x180(%rsp), %r8
xorl %r9d, %r9d
callq 0x44b44
leaq 0x150(%rsp), %rdi
movq %r12, %rsi
callq 0x5bf86
cmpb $0x1, 0xd0(%rsp)
jne 0x51bd3
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x51be5
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x51bf7
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x51c0e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
cmpb $0x1, 0x180(%rsp)
jne 0x51c20
movb $0x0, 0x180(%rsp)
cmpb $0x1, 0x198(%rsp)
jne 0x51c32
movb $0x0, 0x198(%rsp)
cmpb $0x1, 0x130(%rsp)
jne 0x51c44
movb $0x0, 0x130(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x51c60
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x28(%rsp), %rdi
callq 0x45100
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movq %rcx, %rax
sarq $0x4, %rax
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rdx, %rax
movq %rax, 0x60(%rsp)
movq $0x0, 0x70(%rsp)
cmpq $-0x90, %rcx
jle 0x51f40
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x4b398
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq 0x45524
movq 0x60(%rsp), %rbx
movq 0x68(%rsp), %r13
movq %rbp, %rdi
callq 0x44bf2
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x5c0b0
subq %rbx, %rax
shrq $0x5, %rax
cltq
testq %rax, %rax
js 0x51ee3
cmpq %rax, 0x48(%rsp)
jle 0x51ee3
movq 0x40(%rsp), %rcx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rdx, (%rcx,%rax,8)
movq 0xf8(%rsp), %rsi
movq 0x100(%rsp), %rdx
incq %rsi
leaq 0xf0(%rsp), %rdi
callq 0x496a4
movq 0xf0(%rsp), %rdx
movq 0x100(%rsp), %rax
testq %rdx, %rdx
sete %cl
testq %rax, %rax
setns %sil
orb %cl, %sil
je 0x51ec4
movq 0xf8(%rsp), %rcx
testq %rcx, %rcx
jle 0x51f02
cmpq 0x48(%rsp), %rax
jne 0x51f21
testq %rax, %rax
jle 0x51d99
leaq (%rdx,%rcx,8), %rdx
addq $-0x8, %rdx
movq 0x40(%rsp), %rsi
shlq $0x3, %rcx
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm0
movsd %xmm0, (%rdx)
incq %rdi
addq %rcx, %rdx
cmpq %rdi, %rax
jne 0x51d85
movq %r12, %rdi
callq 0x37440
movq 0x40(%rsp), %rdi
callq 0x14720
addq $0x90, %rbp
jmp 0x51a87
cmpb $0x1, 0x2e0(%rsp)
jne 0x51dd6
leaq 0x2e8(%rsp), %rdi
callq 0x36866
movb $0x0, 0x2e0(%rsp)
leaq 0x2c8(%rsp), %rdi
callq 0x36ef6
movq 0x2a8(%rsp), %rdi
leaq 0x2b8(%rsp), %rax
cmpq %rax, %rdi
leaq 0x2a8(%rsp), %rbx
je 0x51e10
movq 0x2b8(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x178(%rsp), %rax
addq $0x18, %rax
cmpq $0x30, %rax
jne 0x51658
leaq 0x150(%rsp), %rsi
leaq 0xf0(%rsp), %rdx
movq 0x170(%rsp), %r14
movq %r14, %rdi
callq 0x559e6
cmpb $0x1, 0x3a0(%rsp)
jne 0x51e64
leaq 0x3a8(%rsp), %rbx
movq %rbx, %rdi
callq 0x36866
movb $0x0, -0x8(%rbx)
leaq 0x388(%rsp), %rbx
movq %rbx, %rdi
callq 0x36ef6
movq -0x20(%rbx), %rdi
leaq 0x378(%rsp), %rax
cmpq %rax, %rdi
je 0x51e95
movq 0x378(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0xf0(%rsp), %rdi
callq 0x14720
leaq 0x150(%rsp), %rdi
callq 0x36ef6
movq %r14, %rax
addq $0x3d8, %rsp # imm = 0x3D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f40e(%rip), %rdi # 0xb12d9
leaq 0x5f4b1(%rip), %rsi # 0xb1383
leaq 0x609a6(%rip), %rcx # 0xb287f
movl $0xb2, %edx
callq 0x143c0
leaq 0x61889(%rip), %rdi # 0xb3773
leaq 0x6189f(%rip), %rsi # 0xb3790
leaq 0x6284f(%rip), %rcx # 0xb4747
movl $0x1ab, %edx # imm = 0x1AB
callq 0x143c0
leaq 0x5f211(%rip), %rdi # 0xb111a
leaq 0x5f2b1(%rip), %rsi # 0xb11c1
leaq 0x64833(%rip), %rcx # 0xb674a
movl $0x7a, %edx
callq 0x143c0
leaq 0x60f6e(%rip), %rdi # 0xb2e96
leaq 0x60fd0(%rip), %rsi # 0xb2eff
leaq 0x648b9(%rip), %rcx # 0xb67ef
movl $0x106, %edx # imm = 0x106
callq 0x143c0
leaq 0x5fd85(%rip), %rdi # 0xb1ccc
leaq 0x5fe13(%rip), %rsi # 0xb1d61
leaq 0x64f70(%rip), %rcx # 0xb6ec5
movl $0x4a, %edx
callq 0x143c0
leaq 0x5fd66(%rip), %rdi # 0xb1ccc
leaq 0x5fdf4(%rip), %rsi # 0xb1d61
leaq 0x83146(%rip), %rcx # 0xd50ba
jmp 0x51f55
jmp 0x5204b
movq %rax, %rbx
cmpb $0x1, 0x318(%rsp)
jne 0x51f98
movq %r15, %rdi
callq 0x36866
movb $0x0, 0x318(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x36866
jmp 0x51fa7
movq %rax, %rbx
leaq 0x1f0(%rsp), %rdi
callq 0x36ef6
movq 0x1b0(%rsp), %rdi
cmpq %r14, %rdi
je 0x52213
movq 0x1c0(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x52213
movq %rax, %rbx
jmp 0x52213
jmp 0x5204b
movq %rax, %rbx
jmp 0x52220
jmp 0x521f6
movq %rax, %rbx
cmpb $0x1, 0xd0(%rsp)
jne 0x52006
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x52018
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x5202a
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x52206
movq 0x70(%rsp), %rsi
jmp 0x520b2
jmp 0x5204b
jmp 0x521f6
jmp 0x521f6
movq %rax, %rbx
jmp 0x52206
movq %rax, %rbx
jmp 0x52084
movq %rax, %rbx
cmpb $0x1, 0x228(%rsp)
jne 0x5207a
leaq 0x230(%rsp), %rdi
callq 0x36866
movb $0x0, 0x228(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x36866
leaq 0x1d0(%rsp), %rdi
callq 0x36ef6
movq 0x110(%rsp), %rdi
leaq 0x120(%rsp), %rax
cmpq %rax, %rdi
je 0x52206
movq 0x120(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x52206
jmp 0x521f6
jmp 0x521f6
jmp 0x521f6
jmp 0x5216a
jmp 0x521f6
movq %rax, %rbx
cmpb $0x1, 0xd0(%rsp)
jne 0x520ed
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x520ff
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x52111
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x52132
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x52132
movq %rax, %rbx
jmp 0x52198
movq %rax, %rbx
cmpb $0x1, 0x180(%rsp)
jne 0x52144
movb $0x0, 0x180(%rsp)
cmpb $0x1, 0x198(%rsp)
jne 0x52156
movb $0x0, 0x198(%rsp)
cmpb $0x1, 0x130(%rsp)
jne 0x5216d
movb $0x0, 0x130(%rsp)
jmp 0x5216d
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x521f9
movq 0x50(%rsp), %rsi
jmp 0x521ec
jmp 0x521f6
jmp 0x521f6
jmp 0x521f6
jmp 0x521f6
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x37440
movq 0x40(%rsp), %rdi
callq 0x14720
jmp 0x521f9
movq %rax, %rbx
cmpb $0x1, 0xd0(%rsp)
jne 0x521b9
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x521cb
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x521dd
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x521f9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x521f9
movq %rax, %rbx
leaq 0x2a8(%rsp), %rdi
callq 0x369a2
leaq 0x368(%rsp), %rdi
callq 0x369a2
movq 0xf0(%rsp), %rdi
callq 0x14720
leaq 0x150(%rsp), %rdi
callq 0x36ef6
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::_adjacent_verts(std::vector<std::set<int, std::less<int>, std::allocator<int>>, std::allocator<std::set<int, std::less<int>, std::allocator<int>>>>, int)
|
Facet _adjacent_verts(std::vector<Facet> facets, int vert) {
std::set<int> ret;
for (const auto& facetVerts : facets) {
if (std::find(facetVerts.begin(), facetVerts.end(), vert) !=
facetVerts.end()) {
ret.insert(facetVerts.begin(), facetVerts.end());
}
}
ret.erase(vert);
return ret;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x522b6
movq 0x18(%r12), %r14
leaq 0x8(%r12), %r15
movq %r14, %rax
cmpq %r15, %r14
je 0x5229d
movl 0x4(%rsp), %ebp
movq %r14, %rax
cmpl %ebp, 0x20(%rax)
je 0x5229d
movq %rax, %rdi
callq 0x146f0
cmpq %r15, %rax
jne 0x52289
jmp 0x522b0
cmpq %r15, %rax
je 0x522b0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5c1d8
addq $0x30, %r12
jmp 0x5226b
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x5c3f2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5c470
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x522e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x55a1c
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::configureFullPolarPanner(ear::Layout const&)
|
std::shared_ptr<PointSourcePanner> configureFullPolarPanner(
const Layout& layout) {
std::vector<Eigen::Vector3d> positionsReal;
std::vector<Eigen::Vector3d> positionsNominal;
std::set<int> virtualVerts;
Eigen::MatrixXd downmix;
std::tie(positionsReal, positionsNominal, virtualVerts, downmix) =
getAugmentedLayout(layout);
// Facets of the convex hull; each set represents a facet and contains the
// indices of its corners in positions.
auto facets_it = FACETS.find(layout.name());
std::vector<Facet> facets = facets_it != FACETS.end()
? facets_it->second
: convex_hull(positionsNominal);
// Turn the facets into regions for the point source panner.
std::vector<std::unique_ptr<RegionHandler>> regions;
// Facets adjacent to one of the virtual speakers are turned into virtual
// ngons, with an equal power downmix from the virtual speaker to the real
// speakers.
for (int virtualVert : virtualVerts) {
Facet realVerts = _adjacent_verts(facets, virtualVert);
ear_assert(!doIntersect(realVerts.begin(), realVerts.end(),
virtualVerts.begin(), virtualVerts.end()),
"invalid triangulation");
std::vector<int> realVertsVec(realVerts.begin(), realVerts.end());
Eigen::Map<Eigen::VectorXi> outputChannels(realVertsVec.data(),
realVertsVec.size());
Eigen::MatrixXd positions(outputChannels.size(), 3);
int rowIndex = 0;
for (int vert : realVerts) {
positions.row(rowIndex) = positionsReal[vert];
++rowIndex;
}
Eigen::Vector3d centrePosition = positionsReal[virtualVert];
Eigen::VectorXd centreDownmix(outputChannels.size());
centreDownmix.fill(1.0 /
std::sqrt(static_cast<double>(outputChannels.size())));
regions.push_back(boost::make_unique<VirtualNgon>(
outputChannels, positions, centrePosition, centreDownmix));
}
// Facets not adjacent to virtual speakers are turned into triplets or
// quads. In the supported layouts there are never facets with more
// vertices.
for (const auto& facetVerts : facets) {
if (doIntersect(facetVerts.begin(), facetVerts.end(),
virtualVerts.begin(), virtualVerts.end())) {
continue;
}
if (facetVerts.size() == 3) {
std::vector<int> facetVertsVec(facetVerts.begin(), facetVerts.end());
Eigen::Vector3i outputChannels(facetVertsVec.data());
Eigen::MatrixXd positions(outputChannels.size(), 3);
int rowIndex = 0;
for (int vert : facetVerts) {
positions.row(rowIndex) = positionsReal[vert];
++rowIndex;
}
regions.push_back(
boost::make_unique<Triplet>(outputChannels, positions));
} else if (facetVerts.size() == 4) {
std::vector<int> facetVertsVec(facetVerts.begin(), facetVerts.end());
Eigen::Vector4i outputChannels(facetVertsVec.data());
Eigen::MatrixXd positions(outputChannels.size(), 3);
int rowIndex = 0;
for (int vert : facetVerts) {
positions.row(rowIndex) = positionsReal[vert];
++rowIndex;
}
regions.push_back(
boost::make_unique<QuadRegion>(outputChannels, positions));
} else {
throw internal_error(
"facets with more than 4 vertices are not supported");
}
}
return std::make_shared<PointSourcePannerDownmix>(
std::make_shared<PolarPointSourcePanner>(std::move(regions)), downmix);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r15
xorl %eax, %eax
movq %rax, 0xb0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xa0(%rsp)
movq %rax, 0x170(%rsp)
movapd %xmm0, 0x160(%rsp)
leaq 0x1d8(%rsp), %r12
movl $0x0, (%r12)
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
movq %rax, 0x1c0(%rsp)
movapd %xmm0, 0x1b0(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x53f5f
leaq 0x1b0(%rsp), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
leaq 0x1d0(%rsp), %rax
movq %rax, 0x8(%rdi)
leaq 0x160(%rsp), %rax
movq %rax, 0x10(%rdi)
leaq 0xa0(%rsp), %rax
movq %rax, 0x18(%rdi)
leaq 0xc0(%rsp), %r14
movq %r14, %rsi
callq 0x5536c
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x525d7
movq 0x130(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq 0x108(%rsp), %rdi
testq %rdi, %rdi
je 0x525f4
movq 0x118(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
leaq 0xd8(%rsp), %r14
movq %r14, %rdi
callq 0x55a1c
movq -0x18(%r14), %rdi
callq 0x14720
leaq 0xc0(%rsp), %rdi
movq %rbx, %rsi
callq 0x450de
leaq 0xbe724(%rip), %r14 # 0x110d48
leaq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq 0x5d002
movq %rax, %rbx
leaq 0xd0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52658
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x145f0
addq $0x8, %r14
cmpq %r14, %rbx
je 0x52677
addq $0x40, %rbx
leaq 0x198(%rsp), %rdi
movq %rbx, %rsi
callq 0x553a2
jmp 0x52694
leaq 0x198(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movsd 0x7af99(%rip), %xmm0 # 0xcd628
callq 0x6fb30
movq %r15, 0x1c8(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x140(%rsp)
movq $0x0, 0x150(%rsp)
movq 0x1e8(%rsp), %r14
cmpq %r12, %r14
je 0x52a76
leaq 0x200(%rsp), %r15
leaq 0xc0(%rsp), %r13
leaq 0x20(%rsp), %rbx
movslq 0x20(%r14), %rbp
movq %r15, %rdi
leaq 0x198(%rsp), %rsi
callq 0x553a2
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x52235
movq %r15, %rdi
callq 0x5543e
movq 0xd8(%rsp), %rdi
movq 0x1e8(%rsp), %rdx
leaq 0xc8(%rsp), %r15
movq %r15, %rsi
movq %r12, %rcx
callq 0x55485
testb %al, %al
jne 0x52fa7
movq %rbp, 0x60(%rsp)
movq 0xd8(%rsp), %rsi
movq %rsp, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x554f4
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
js 0x52ff9
movq %rbx, %rbp
movq %r13, %rbx
movq %r14, 0x180(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
leaq (%rdx,%rdx,2), %rsi
movl $0x3, %ecx
leaq 0x40(%rsp), %rdi
callq 0x3e05a
movq 0xd8(%rsp), %rax
movq 0xa0(%rsp), %r13
cmpq %r15, %rax
je 0x5283d
movq 0x40(%rsp), %r14
movq 0x50(%rsp), %r12
testq %r14, %r14
setne %cl
testq %r12, %r12
sets %dl
testb %dl, %cl
jne 0x53056
xorl %r15d, %r15d
movq 0x48(%rsp), %rcx
cmpq %r15, %rcx
jle 0x52f3b
cmpq $0x3, %r12
jne 0x52f5a
movslq 0x20(%rax), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (,%rdx,8), %rdx
addq %r13, %rdx
shlq $0x3, %rcx
movq %r14, %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi)
incq %rdi
addq %rcx, %rsi
cmpq $0x3, %rdi
jne 0x5280c
incq %r15
movq %rax, %rdi
callq 0x146f0
addq $0x8, %r14
leaq 0xc8(%rsp), %rcx
cmpq %rcx, %rax
jne 0x527d8
movq 0x60(%rsp), %rax
leaq (%rax,%rax,2), %rax
movq 0x10(%r13,%rax,8), %rcx
movq %rcx, 0x90(%rsp)
movupd (%r13,%rax,8), %xmm0
movapd %xmm0, 0x80(%rsp)
movq 0x28(%rsp), %r14
xorpd %xmm0, %xmm0
movapd %xmm0, 0x70(%rsp)
testq %r14, %r14
js 0x53018
movq %rbx, %r13
movq %rbp, %rbx
je 0x528c5
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, %r14
ja 0x52f79
leaq (,%r14,8), %rdi
callq 0x147f0
cmpq $0x1, %r14
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x53075
testq %rax, %rax
je 0x52f79
movq %rax, 0x70(%rsp)
movq %r14, 0x78(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
ucomisd 0x7ad56(%rip), %xmm0 # 0xcd630
jb 0x528e2
sqrtsd %xmm0, %xmm0
jmp 0x528e7
callq 0x144a0
leaq 0x1d8(%rsp), %r12
movq 0x180(%rsp), %r14
leaq 0x200(%rsp), %r15
movq 0x78(%rsp), %rcx
testq %rcx, %rcx
js 0x53037
je 0x529c3
movsd 0x5c6ed(%rip), %xmm1 # 0xaf008
divsd %xmm0, %xmm1
movq 0x70(%rsp), %rax
movabsq $0x1fffffffffffffff, %rsi # imm = 0x1FFFFFFFFFFFFFFF
addq %rsi, %rcx
movq %rcx, %rdx
andq %rsi, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
pxor 0x5c73a(%rip), %xmm0 # 0xaf090
xorl %edx, %edx
movq %rdx, %xmm2
pshufd $0x44, %xmm2, %xmm2 # xmm2 = xmm2[0,1,0,1]
por 0x5c716(%rip), %xmm2 # 0xaf080
pxor 0x5c71e(%rip), %xmm2 # 0xaf090
movdqa %xmm2, %xmm3
pcmpgtd %xmm0, %xmm3
pcmpeqd %xmm0, %xmm2
pshufd $0xf5, %xmm2, %xmm4 # xmm4 = xmm2[1,1,3,3]
pand %xmm3, %xmm4
pshufd $0xf5, %xmm3, %xmm2 # xmm2 = xmm3[1,1,3,3]
por %xmm4, %xmm2
movd %xmm2, %esi
notl %esi
testb $0x1, %sil
je 0x529a1
movsd %xmm1, (%rax,%rdx,8)
pxor 0x7ad17(%rip), %xmm2 # 0xcd6c0
pextrw $0x4, %xmm2, %esi
testb $0x1, %sil
je 0x529ba
movsd %xmm1, 0x8(%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x52958
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
leaq 0x40(%rsp), %rdx
leaq 0x80(%rsp), %rcx
leaq 0x70(%rsp), %r8
callq 0x55535
movq 0x68(%rsp), %rax
movq $0x0, 0x68(%rsp)
movq %rax, 0x58(%rsp)
leaq 0x140(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5a6a8
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x52a17
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x58(%rsp)
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x52a30
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x70(%rsp), %rdi
callq 0x14720
movq 0x40(%rsp), %rdi
callq 0x14720
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x52a5a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq %r13, %rdi
callq 0x55a1c
movq %r14, %rdi
callq 0x146f0
movq %rax, %r14
cmpq %r12, %rax
jne 0x526db
movq 0x198(%rsp), %rbp
movq 0x1a0(%rsp), %rbx
cmpq %rbx, %rbp
je 0x52e35
movq %rsp, %r15
movq %rbx, 0x60(%rsp)
movq 0x18(%rbp), %rdi
leaq 0x8(%rbp), %r14
movq 0x1e8(%rsp), %rdx
movq %r14, %rsi
movq %r12, %rcx
callq 0x55485
testb %al, %al
jne 0x52e28
movq 0x28(%rbp), %rax
cmpq $0x4, %rax
je 0x52cad
cmpq $0x3, %rax
jne 0x53094
movq 0x18(%rbp), %rsi
movq %r15, %rdi
movq %r14, %rdx
leaq 0xc0(%rsp), %rcx
callq 0x554f4
movq (%rsp), %rax
movsd (%rax), %xmm0
movapd %xmm0, 0x180(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x9c(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x9, %esi
movl $0x3, %edx
movl $0x3, %ecx
leaq 0x20(%rsp), %rdi
callq 0x3e05a
movq 0x18(%rbp), %rax
cmpq %r14, %rax
je 0x52bb8
movq 0x20(%rsp), %r15
movq 0x30(%rsp), %r12
testq %r15, %r15
setne %cl
testq %r12, %r12
sets %dl
testb %dl, %cl
jne 0x53056
movq 0xa0(%rsp), %rbx
xorl %r13d, %r13d
movq 0x28(%rsp), %rcx
cmpq %r13, %rcx
jle 0x52f3b
cmpq $0x3, %r12
jne 0x52f5a
movslq 0x20(%rax), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rbx,%rdx,8), %rdx
shlq $0x3, %rcx
movq %r15, %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi)
incq %rdi
addq %rcx, %rsi
cmpq $0x3, %rdi
jne 0x52b8f
incq %r13
movq %rax, %rdi
callq 0x146f0
addq $0x8, %r15
cmpq %r14, %rax
jne 0x52b62
movl $0x78, %edi
callq 0x145c0
movq %rax, %r14
movaps 0x180(%rsp), %xmm0
movlps %xmm0, 0x40(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x48(%rsp)
cmpq $0x3, 0x28(%rsp)
leaq 0x1d8(%rsp), %r12
movq 0x60(%rsp), %rbx
jne 0x530f2
cmpq $0x3, 0x30(%rsp)
jne 0x530f2
movq 0x20(%rsp), %rax
movaps (%rax), %xmm0
movaps %xmm0, 0xc0(%rsp)
movaps 0x10(%rax), %xmm0
movaps %xmm0, 0xd0(%rsp)
movaps 0x20(%rax), %xmm0
movaps %xmm0, 0xe0(%rsp)
movaps 0x30(%rax), %xmm0
movaps %xmm0, 0xf0(%rsp)
movsd 0x40(%rax), %xmm0
movsd %xmm0, 0x100(%rsp)
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x4f0a0
movq %r14, 0x80(%rsp)
leaq 0x140(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x5a6a8
movq %rsp, %r15
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x52c8c
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rdi
callq 0x14720
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x52e28
movq 0x10(%rsp), %rsi
jmp 0x52e20
movq 0x18(%rbp), %rsi
leaq 0xc0(%rsp), %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x554f4
movq 0xc0(%rsp), %rax
movupd (%rax), %xmm0
movapd %xmm0, 0x20(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0xc, %esi
movl $0x4, %edx
movl $0x3, %ecx
movq %r15, %rdi
callq 0x3e05a
movq 0x18(%rbp), %rax
cmpq %r14, %rax
je 0x52d86
movq (%rsp), %r15
movq 0x10(%rsp), %r12
testq %r15, %r15
setne %cl
testq %r12, %r12
sets %dl
testb %dl, %cl
jne 0x53056
movq 0xa0(%rsp), %rbx
xorl %r13d, %r13d
movq 0x8(%rsp), %rcx
cmpq %r13, %rcx
jle 0x52f3b
cmpq $0x3, %r12
jne 0x52f5a
movslq 0x20(%rax), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rbx,%rdx,8), %rdx
shlq $0x3, %rcx
movq %r15, %rsi
xorl %edi, %edi
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rsi)
incq %rdi
addq %rcx, %rsi
cmpq $0x3, %rdi
jne 0x52d5d
incq %r13
movq %rax, %rdi
callq 0x146f0
addq $0x8, %r15
cmpq %r14, %rax
jne 0x52d30
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %r15
movq %r15, %rdx
callq 0x5562e
movq 0x80(%rsp), %rax
movq $0x0, 0x80(%rsp)
movq %rax, 0x40(%rsp)
leaq 0x140(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5a6a8
leaq 0x1d8(%rsp), %r12
movq 0x60(%rsp), %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x52de6
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x40(%rsp)
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x52e02
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rsp), %rdi
callq 0x14720
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x52e28
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
addq $0x30, %rbp
cmpq %rbx, %rbp
jne 0x52a97
leaq 0x8(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
leaq 0x140(%rsp), %rcx
callq 0x5c9ba
leaq 0xc8(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0xc0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
leaq 0x1b0(%rsp), %r8
callq 0x5d2e8
movq 0x1c8(%rsp), %rbx
movaps 0xc0(%rsp), %xmm0
xorl %eax, %eax
movq %rax, 0xc8(%rsp)
movups %xmm0, (%rbx)
movq %rax, 0xc0(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x52eb8
callq 0x39030
leaq 0x140(%rsp), %rdi
callq 0x54b50
leaq 0x198(%rsp), %rdi
callq 0x5543e
movq 0x1b0(%rsp), %rdi
callq 0x14720
leaq 0x1d0(%rsp), %rdi
callq 0x55a1c
movq 0x160(%rsp), %rdi
testq %rdi, %rdi
je 0x52f09
movq 0x170(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x52f26
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq %rbx, %rax
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e1d8(%rip), %rdi # 0xb111a
leaq 0x5e278(%rip), %rsi # 0xb11c1
leaq 0x637fa(%rip), %rcx # 0xb674a
movl $0x7a, %edx
callq 0x143c0
leaq 0x5ff35(%rip), %rdi # 0xb2e96
leaq 0x5ff97(%rip), %rsi # 0xb2eff
leaq 0x63880(%rip), %rcx # 0xb67ef
movl $0x106, %edx # imm = 0x106
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xbcfae(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xbd000(%rip), %rsi # 0x10ff98
movq 0xbcf69(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movl $0x10, %edi
callq 0x14290
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7a860(%rip), %rsi # 0xcd824
leaq 0x7a86e(%rip), %rdx # 0xcd839
movq %rsp, %rdi
callq 0x37fd8
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
callq 0x42fb0
xorl %ebp, %ebp
leaq 0xb869e(%rip), %rsi # 0x10b688
movq 0xbcf87(%rip), %rdx # 0x10ff78
movq %r14, %rdi
callq 0x14a60
leaq 0x5fe89(%rip), %rdi # 0xb2e89
leaq 0x5e37c(%rip), %rsi # 0xb1383
leaq 0x82cf9(%rip), %rcx # 0xd5d07
movl $0xa6, %edx
callq 0x143c0
leaq 0x6065e(%rip), %rdi # 0xb367d
leaq 0x5dcf9(%rip), %rsi # 0xb0d1f
leaq 0x616a8(%rip), %rcx # 0xb46d5
movl $0x130, %edx # imm = 0x130
callq 0x143c0
leaq 0x5ec8e(%rip), %rdi # 0xb1ccc
leaq 0x5ed1c(%rip), %rsi # 0xb1d61
leaq 0x63e79(%rip), %rcx # 0xb6ec5
movl $0x4a, %edx
callq 0x143c0
leaq 0x5e27c(%rip), %rdi # 0xb12d9
leaq 0x5e31f(%rip), %rsi # 0xb1383
leaq 0x5f814(%rip), %rcx # 0xb287f
movl $0xb2, %edx
callq 0x143c0
leaq 0x5dd8f(%rip), %rdi # 0xb0e0b
leaq 0x5de43(%rip), %rsi # 0xb0ec6
leaq 0x5dea9(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
movl $0x10, %edi
callq 0x14290
movq %rax, %r14
leaq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
movq %rax, (%rdi)
leaq 0x7a77f(%rip), %rsi # 0xcd83a
leaq 0x7a7aa(%rip), %rdx # 0xcd86c
callq 0x37fd8
movb $0x1, %bpl
leaq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq 0x42fb0
xorl %ebp, %ebp
leaq 0xb85a5(%rip), %rsi # 0x10b688
movq 0xbce8e(%rip), %rdx # 0x10ff78
movq %r14, %rdi
callq 0x14a60
leaq 0x5da97(%rip), %rdi # 0xb0b90
leaq 0x5dc1f(%rip), %rsi # 0xb0d1f
leaq 0x7ab13(%rip), %rcx # 0xcdc1a
movl $0x115, %edx # imm = 0x115
callq 0x143c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x53326
callq 0x39030
jmp 0x53326
jmp 0x532cb
jmp 0x53162
movq %rax, %rbx
leaq 0xd0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53340
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x53340
jmp 0x53162
movq %rax, %rbx
jmp 0x53340
movq %rax, %rbx
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x53192
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x5319f
jmp 0x53326
movq %rax, %rbx
movq %r14, %rdi
callq 0x14460
jmp 0x53326
movq %rax, %rbx
movl $0x78, %esi
movq %r14, %rdi
callq 0x145f0
jmp 0x53242
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x531d4
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x40(%rsp)
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x53203
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x53203
jmp 0x531f6
jmp 0x53200
movq %rax, %rbx
jmp 0x53242
jmp 0x532cb
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x14720
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x53326
movq 0xd0(%rsp), %rsi
jmp 0x5325e
jmp 0x532cb
movq %rax, %rbx
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x53242
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rdi
callq 0x14720
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x53326
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
jmp 0x53326
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x53284
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x53291
jmp 0x53319
movq %rax, %rbx
movq %r14, %rdi
callq 0x14460
jmp 0x53319
jmp 0x532ec
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x532b0
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x58(%rsp)
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x532ef
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x532ef
movq %rax, %rbx
jmp 0x53326
movq %rax, %rbx
leaq 0x200(%rsp), %rdi
callq 0x5543e
jmp 0x53326
movq %rax, %rbx
jmp 0x53319
movq %rax, %rbx
jmp 0x532f9
movq %rax, %rbx
movq 0x70(%rsp), %rdi
callq 0x14720
movq 0x40(%rsp), %rdi
callq 0x14720
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x53319
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
leaq 0xc0(%rsp), %rdi
callq 0x55a1c
leaq 0x140(%rsp), %rdi
callq 0x54b50
leaq 0x198(%rsp), %rdi
callq 0x5543e
movq 0x1b0(%rsp), %rdi
callq 0x14720
leaq 0x1d0(%rsp), %rdi
callq 0x55a1c
movq 0x160(%rsp), %rdi
testq %rdi, %rdi
je 0x53377
movq 0x170(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x53394
movq 0xb0(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::StereoPannerDownmix::handle(Eigen::Matrix<double, 3, 1, 0, 3, 1>) const
|
boost::optional<Eigen::VectorXd> StereoPannerDownmix::handle(
Eigen::Vector3d position) const {
Eigen::MatrixXd downmix(2, 5);
downmix << 1.0, 0.0, std::sqrt(3.0) / 3.0, std::sqrt(0.5), 0.0, //
0.0, 1.0, std::sqrt(3.0) / 3.0, 0.0, std::sqrt(0.5);
// pan with 0+5+0, downmix and power normalise
boost::optional<Eigen::VectorXd> pv = _psp->handle(position);
if (pv) {
Eigen::VectorXd _pv = pv.get();
Eigen::VectorXd pvDownmix = downmix * _pv;
pvDownmix /= pvDownmix.norm();
// vary the output level by the balance between the front and rear
// loudspeakers; 0dB at the front to -3dB at the back
double front = _pv.head(3).maxCoeff();
double back = _pv.tail(2).maxCoeff();
pvDownmix = pvDownmix * std::pow(0.5, (0.5 * back / (front + back)));
return pvDownmix;
}
return boost::none;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x68(%rsp)
pxor %xmm0, %xmm0
leaq 0x70(%rsp), %r14
movdqa %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0xa, %esi
movl $0x2, %edx
movl $0x5, %ecx
movq %r14, %rdi
callq 0x3e05a
movq %r14, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movl $0x1, %eax
movq %rax, 0x40(%rsp)
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x78(%rsp)
jle 0x537fb
cmpq $0x0, 0x80(%rsp)
jle 0x537fb
movq 0x70(%rsp), %rax
movabsq $0x3ff0000000000000, %rbp # imm = 0x3FF0000000000000
movq %rbp, (%rax)
leaq 0xa8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x54fcc
movabsq $0x3fe279a74590331c, %rbx # imm = 0x3FE279A74590331C
leaq 0x88(%rsp), %rsi
movq %rbx, (%rsi)
movq %rax, %rdi
callq 0x54fcc
movabsq $0x3fe6a09e667f3bcd, %r13 # imm = 0x3FE6A09E667F3BCD
leaq 0x18(%rsp), %rsi
movq %r13, (%rsi)
movq %rax, %rdi
callq 0x54fcc
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x54fcc
leaq 0x28(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x54fcc
leaq 0xd8(%rsp), %rsi
movq %rbp, (%rsi)
movq %rax, %rdi
callq 0x54fcc
leaq 0xd0(%rsp), %rsi
movq %rbx, (%rsi)
movq %rax, %rdi
callq 0x54fcc
leaq 0xc8(%rsp), %rsi
movq $0x0, (%rsi)
movq %rax, %rdi
callq 0x54fcc
leaq 0xc0(%rsp), %rsi
movq %r13, (%rsi)
movq %rax, %rdi
callq 0x54fcc
movq 0x48(%rsp), %rcx
addq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rdx
movq 0x10(%rdx), %rax
cmpq 0x8(%rdx), %rcx
je 0x5351b
testq %rax, %rax
jne 0x537dc
xorl %eax, %eax
cmpq %rax, 0x40(%rsp)
jne 0x537dc
movq 0x30(%r12), %rsi
movq 0x10(%r15), %rax
leaq 0xe0(%rsp), %rdx
movq %rax, 0x10(%rdx)
movdqu (%r15), %xmm0
movdqa %xmm0, (%rdx)
movq (%rsi), %rax
leaq 0x88(%rsp), %rdi
callq *(%rax)
movb 0x88(%rsp), %al
cmpb $0x1, %al
jne 0x537a4
leaq 0x90(%rsp), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x55e5e
movq 0x80(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x53839
leaq 0x30(%rsp), %rsi
movq %r14, (%rsi)
movq %r15, 0x8(%rsi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5c516
movabsq $0x7ffffffffffffffe, %r12 # imm = 0x7FFFFFFFFFFFFFFE
movq %r14, 0xa8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x53648
jle 0x5386f
movq 0x8(%rsp), %rax
leaq 0x30(%rsp), %rdi
movq %rax, 0x8(%rdi)
leaq 0x28(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x5a5e2
movq 0x10(%rsp), %rax
testq %rax, %rax
js 0x5388e
movq %xmm0, %xmm0 # xmm0 = xmm0[0],zero
sqrtpd %xmm0, %xmm0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
andq %r12, %rdx
cmpq $0x2, %rax
jb 0x5362d
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
xorl %esi, %esi
movapd (%rcx,%rsi,8), %xmm2
divpd %xmm1, %xmm2
movapd %xmm2, (%rcx,%rsi,8)
addq $0x2, %rsi
cmpq %rdx, %rsi
jb 0x53616
cmpq %rax, %rdx
jge 0x53648
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x53632
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rax, 0x30(%rsp)
movq $0x3, 0x38(%rsp)
movq %r15, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq %rcx, 0x60(%rsp)
cmpq $0x2, %rcx
jle 0x5381a
leaq 0xa8(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x10(%rdi)
leaq 0x28(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x5c75a
movsd %xmm0, 0xa0(%rsp)
movq 0x20(%rsp), %rax
leaq -0x2(%rax), %rdx
leaq -0x10(,%rax,8), %rcx
addq 0x18(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq $0x2, 0x38(%rsp)
movq %r15, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rax, 0x60(%rsp)
cmpq $0x1, %rax
jle 0x5381a
leaq 0xa8(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, 0x10(%rdi)
leaq 0x28(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x5c75a
movq 0x68(%rsp), %rbx
movsd 0xa0(%rsp), %xmm1
addsd %xmm0, %xmm1
mulsd 0x79f1f(%rip), %xmm0 # 0xcd638
divsd %xmm1, %xmm0
callq 0x14550
movq 0x10(%rsp), %rax
testq %rax, %rax
js 0x53858
movq 0x8(%rsp), %rcx
andq %rax, %r12
cmpq $0x2, %rax
jb 0x5375f
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
xorl %edx, %edx
movapd (%rcx,%rdx,8), %xmm2
mulpd %xmm1, %xmm2
movapd %xmm2, (%rcx,%rdx,8)
addq $0x2, %rdx
cmpq %r12, %rdx
jb 0x53748
cmpq %rax, %r12
jge 0x5377c
movsd (%rcx,%r12,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%r12,8)
incq %r12
cmpq %r12, %rax
jne 0x53764
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movb $0x1, (%rbx)
movq 0x18(%rsp), %rdi
callq 0x14720
movb 0x88(%rsp), %al
jmp 0x537ac
movq 0x68(%rsp), %rbx
movb $0x0, (%rbx)
testb $0x1, %al
je 0x537bd
movq 0x90(%rsp), %rdi
callq 0x14720
movq 0x70(%rsp), %rdi
callq 0x14720
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x632d0(%rip), %rdi # 0xb6ab3
leaq 0x62771(%rip), %rsi # 0xb5f5b
leaq 0x81b79(%rip), %rcx # 0xd536a
movl $0x7c, %edx
callq 0x143c0
leaq 0x7ee1a(%rip), %rdi # 0xd261c
leaq 0x62752(%rip), %rsi # 0xb5f5b
leaq 0x81ac9(%rip), %rcx # 0xd52d9
movl $0x25, %edx
callq 0x143c0
leaq 0x627ac(%rip), %rdi # 0xb5fcd
leaq 0x5d999(%rip), %rsi # 0xb11c1
leaq 0x7ef4b(%rip), %rcx # 0xd277a
movl $0x93, %edx
callq 0x143c0
leaq 0x5e2cd(%rip), %rdi # 0xb1b0d
leaq 0x5e352(%rip), %rsi # 0xb1b99
leaq 0x81c32(%rip), %rcx # 0xd5480
movl $0x62, %edx
callq 0x143c0
leaq 0x5e46d(%rip), %rdi # 0xb1ccc
leaq 0x5e4fb(%rip), %rsi # 0xb1d61
leaq 0x64597(%rip), %rcx # 0xb7e04
jmp 0x538a3
leaq 0x5d0b6(%rip), %rdi # 0xb092c
leaq 0x5d0f3(%rip), %rsi # 0xb0970
leaq 0x7eae0(%rip), %rcx # 0xd2364
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
leaq 0x5e437(%rip), %rdi # 0xb1ccc
leaq 0x5e4c5(%rip), %rsi # 0xb1d61
leaq 0x63622(%rip), %rcx # 0xb6ec5
movl $0x4a, %edx
callq 0x143c0
jmp 0x538b1
jmp 0x538b1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x14720
jmp 0x538c3
movq %rax, %rbx
movq 0x18(%rsp), %rdi
callq 0x14720
jmp 0x538d2
movq %rax, %rbx
cmpb $0x1, 0x88(%rsp)
jne 0x5390a
movq 0x90(%rsp), %rdi
callq 0x14720
jmp 0x5390a
jmp 0x5391c
jmp 0x538fd
jmp 0x538fd
jmp 0x538fd
jmp 0x538fd
jmp 0x538fd
jmp 0x538fd
jmp 0x538fd
jmp 0x538fd
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x55090
movq 0x70(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
movq %rax, %rbx
jmp 0x5390a
nop
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::checkScreenSpeakers(ear::Layout const&)
|
void checkScreenSpeakers(const Layout& layout) {
for (auto& channel : layout.channels()) {
if (channel.name() == "M+SC" || channel.name() == "M-SC") {
double abs_az = std::abs(channel.polarPosition().azimuth);
if (!((5.0 <= abs_az && abs_az < 25.0) ||
(35.0 <= abs_az && abs_az < 60.0))) {
throw invalid_argument(
"M+SC or M-SC has azimuth not in the allowed ranges of 5 to 25 "
"and 35 to 60 degrees");
}
if (25.0 < abs_az) {
throw not_implemented(
"M+SC and M-SC with azimuths wider than 25 degrees are not "
"currently supported");
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x45106
movq (%rax), %rbx
movq 0x8(%rax), %r13
cmpq %r13, %rbx
je 0x5463e
leaq 0x5b934(%rip), %r14 # 0xafecd
leaq 0x8(%rsp), %r15
leaq 0x5b92d(%rip), %r12 # 0xafed2
movq %rbx, %rdi
callq 0x44bf2
movq %rax, %rdi
movq %r14, %rsi
callq 0x14180
testl %eax, %eax
je 0x545d3
movq %rbx, %rdi
callq 0x44bf2
movq %rax, %rdi
movq %r12, %rsi
callq 0x14180
testl %eax, %eax
jne 0x5462e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x44bf6
movsd 0x8(%rsp), %xmm0
andpd 0x5aa74(%rip), %xmm0 # 0xaf060
ucomisd 0x5b50c(%rip), %xmm0 # 0xafb00
jb 0x54604
movsd 0x79042(%rip), %xmm1 # 0xcd640
ucomisd %xmm0, %xmm1
ja 0x54624
ucomisd 0x7903c(%rip), %xmm0 # 0xcd648
jb 0x546a5
movsd 0x5b4de(%rip), %xmm1 # 0xafaf8
ucomisd %xmm0, %xmm1
jbe 0x546a5
ucomisd 0x79014(%rip), %xmm0 # 0xcd640
ja 0x5464d
addq $0x90, %rbx
cmpq %r13, %rbx
jne 0x545a5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x79256(%rip), %rsi # 0xcd8c0
leaq 0x7929c(%rip), %rdx # 0xcd90d
leaq 0x8(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4aada
xorl %ebp, %ebp
leaq 0xb6a9c(%rip), %rsi # 0x10b130
movq 0xbb8dd(%rip), %rdx # 0x10ff78
movq %rbx, %rdi
callq 0x14a60
jmp 0x54709
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x791ab(%rip), %rsi # 0xcd86d
leaq 0x791f6(%rip), %rdx # 0xcd8bf
leaq 0x8(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x14630
leaq 0xb6b1e(%rip), %rax # 0x10b208
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xb6af6(%rip), %rsi # 0x10b1f0
movq 0xbb7e7(%rip), %rdx # 0x10fee8
movq %rbx, %rdi
callq 0x14a60
jmp 0x5470d
jmp 0x5472e
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x54727
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x54731
jmp 0x54739
movq %rax, %r14
movq %rbx, %rdi
callq 0x14460
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
ear::configureAllocentricPanner(ear::Layout const&)
|
std::shared_ptr<PointSourcePanner> configureAllocentricPanner(
const Layout& layout) {
checkScreenSpeakers(layout);
return std::make_shared<AllocentricPanner>();
}
|
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5456f
movl $0x18, %edi
callq 0x145c0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0xb75a4(%rip), %rcx # 0x10bd10
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0xb7472(%rip), %rdx # 0x10bbf0
addq $0x10, %rdx
movq %rdx, 0x10(%rax)
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
|
/ebu[P]libear/src/common/point_source_panner.cpp
|
Eigen::CommaInitializer<Eigen::IndexedView<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::internal::SingleRange>>::operator,(double const&)
|
EIGEN_DEVICE_FUNC
CommaInitializer& operator,(const Scalar& s)
{
if (m_col==m_xpr.cols())
{
m_row+=m_currentBlockRows;
m_col = 0;
m_currentBlockRows = 1;
eigen_assert(m_row<m_xpr.rows()
&& "Too many rows passed to comma initializer (operator<<)");
}
eigen_assert(m_col<m_xpr.cols()
&& "Too many coefficients passed to comma initializer (operator<<)");
eigen_assert(m_currentBlockRows==1);
m_xpr.coeffRef(m_row, m_col++) = s;
return *this;
}
|
pushq %rax
movq 0x10(%rdi), %rax
cmpq $0x1, %rax
jne 0x54ca0
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq 0x18(%rdi), %rcx
movq %rcx, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
cmpq 0x10(%rax), %rcx
jge 0x54d20
xorl %eax, %eax
jmp 0x54ca6
jge 0x54d3f
cmpq $0x1, 0x18(%rdi)
jne 0x54d01
movsd (%rsi), %xmm0
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
incq %rax
movq %rax, 0x10(%rdi)
testq %rdx, %rdx
js 0x54ce2
cmpq %rdx, 0x10(%rcx)
jle 0x54ce2
movq (%rcx), %rax
movq (%rax), %rax
movq 0x8(%rcx), %rcx
movslq (%rcx,%rdx,4), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq %rdi, %rax
popq %rcx
retq
leaq 0x5ea8a(%rip), %rdi # 0xb3773
leaq 0x5eaa0(%rip), %rsi # 0xb3790
leaq 0x7e7d9(%rip), %rcx # 0xd34d0
movl $0xa3, %edx
callq 0x143c0
leaq 0x621a7(%rip), %rdi # 0xb6eaf
leaq 0x6124c(%rip), %rsi # 0xb5f5b
leaq 0x7ec3f(%rip), %rcx # 0xd3955
movl $0x4d, %edx
callq 0x143c0
leaq 0x62049(%rip), %rdi # 0xb6d70
leaq 0x6122d(%rip), %rsi # 0xb5f5b
leaq 0x7ec20(%rip), %rcx # 0xd3955
movl $0x49, %edx
callq 0x143c0
leaq 0x62112(%rip), %rdi # 0xb6e58
leaq 0x6120e(%rip), %rsi # 0xb5f5b
leaq 0x7ec01(%rip), %rcx # 0xd3955
movl $0x4c, %edx
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/CommaInitializer.h
|
bool ear::doIntersect<std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>>(std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>)
|
bool doIntersect(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2) {
while (first1 != last1 && first2 != last2) {
if (*first1 < *first2)
++first1;
else if (*first2 < *first1)
++first2;
else {
return true;
}
}
return false;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
cmpq %rsi, %rdi
setne %al
cmpq %rcx, %rdx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x554e1
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl 0x20(%r12), %eax
movl 0x20(%r15), %ecx
cmpl %ecx, %eax
jge 0x554c6
movq %r12, %rdi
callq 0x146f0
movq %rax, %r12
jmp 0x554d3
jle 0x554e5
movq %r15, %rdi
callq 0x146f0
movq %rax, %r15
xorl %eax, %eax
cmpq %r14, %r12
je 0x554e7
cmpq %rbx, %r15
jne 0x554ac
jmp 0x554e7
xorl %eax, %eax
jmp 0x554e7
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/ebu[P]libear/src/common/helpers/eigen_helpers.hpp
|
bool Eigen::RefBase<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>::construct<Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::Stride<-1, 0>>>(Eigen::Map<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::Stride<-1, 0>>&)
|
EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue* data() { return this->m_data; }
|
movq (%rsi), %r8
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movq %r8, (%rdi)
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
testq %r8, %r8
sete %sil
movq %rdx, %r8
orq %rax, %r8
setns %r8b
orb %sil, %r8b
je 0x5757e
testq %rcx, %rcx
cmoveq %rax, %rcx
cmpq $0x1, %rdx
cmoveq %rax, %rcx
movq %rcx, 0x18(%rdi)
movb $0x1, %al
retq
pushq %rax
leaq 0x59d53(%rip), %rdi # 0xb12d9
leaq 0x59df6(%rip), %rsi # 0xb1383
leaq 0x772ca(%rip), %rcx # 0xce85e
movl $0xb2, %edx
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/MapBase.h
|
void Eigen::internal::outer_product_selector_run<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, -1, false>, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false>, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>, 1, -1, false>, Eigen::internal::generic_product_impl<Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false>, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>, 1, -1, false>, Eigen::DenseShape, Eigen::DenseShape, 5>::sub>(Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, -1, false>&, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false> const&, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>, 1, -1, false> const&, Eigen::internal::generic_product_impl<Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false>, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>, 1, -1, false>, Eigen::DenseShape, Eigen::DenseShape, 5>::sub const&, Eigen::internal::false_type const&)
|
void EIGEN_DEVICE_FUNC outer_product_selector_run(Dst& dst, const Lhs &lhs, const Rhs &rhs, const Func& func, const false_type&)
{
evaluator<Rhs> rhsEval(rhs);
ei_declare_local_nested_eval(Lhs,lhs,Rhs::SizeAtCompileTime,actual_lhs);
// FIXME if cols is large enough, then it might be useful to make sure that lhs is sequentially stored
// FIXME not very good if rhs is real and lhs complex while alpha is real too
const Index cols = dst.cols();
for (Index j=0; j<cols; ++j)
func(dst.col(j), rhsEval.coeff(Index(0),j) * actual_lhs);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rcx, 0x10(%rsp)
movq %rdi, %r14
movq (%rdx), %r15
movq 0x30(%rdx), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsi), %rbp
addq $0x10, %rsi
leaq 0x110(%rsp), %rdi
movl $0xb, %ecx
rep movsq (%rsi), %es:(%rdi)
movq 0x10(%r14), %rbx
testq %rbx, %rbx
jle 0x5777c
leaq 0x30(%rsp), %r13
shlq $0x3, (%rsp)
xorl %r12d, %r12d
movq 0x18(%r14), %rax
movq 0x18(%rax), %rax
imulq %r12, %rax
movq (%r14), %rcx
movq 0x8(%r14), %rdx
leaq (%rcx,%rax,8), %rax
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
setns %cl
orb %al, %cl
je 0x577cc
movq 0x30(%r14), %rax
movq %rax, 0x30(%r13)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%r13)
movups %xmm1, 0x10(%r13)
movups %xmm0, (%r13)
movq $0x0, 0x68(%rsp)
movq %r12, 0x70(%rsp)
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x78(%rsp)
cmpq %r12, 0x10(%r14)
jle 0x577ad
testq %rbp, %rbp
js 0x5778e
movsd (%r15), %xmm0
movq %rbp, 0x88(%rsp)
movsd %xmm0, 0x98(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq %rbp, 0xa8(%rsp)
movl $0xb, %ecx
leaq 0xb0(%rsp), %rdi
leaq 0x110(%rsp), %rsi
rep movsq (%rsi), %es:(%rdi)
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x577ec
incq %r12
addq (%rsp), %r15
cmpq %r12, %rbx
jne 0x5768d
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a537(%rip), %rdi # 0xb1ccc
leaq 0x5a5c5(%rip), %rsi # 0xb1d61
leaq 0x60661(%rip), %rcx # 0xb7e04
movl $0x4a, %edx
callq 0x143c0
leaq 0x59966(%rip), %rdi # 0xb111a
leaq 0x59a06(%rip), %rsi # 0xb11c1
leaq 0x77d19(%rip), %rcx # 0xcf4db
movl $0x7a, %edx
callq 0x143c0
leaq 0x59b06(%rip), %rdi # 0xb12d9
leaq 0x59ba9(%rip), %rsi # 0xb1383
leaq 0x77ddc(%rip), %rcx # 0xcf5bd
movl $0xb2, %edx
callq 0x143c0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
void Eigen::internal::generic_product_impl<Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false>, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>, 1, -1, false>, Eigen::DenseShape, Eigen::DenseShape, 5>::sub::operator()<Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, -1, false>, -1, 1, true>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false> const>>(Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, -1, false>, -1, 1, true> const&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, Eigen::Block<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>, -1, 1, false> const> const&) const
|
EIGEN_DEVICE_FUNC void operator()(const Dst& dst, const Src& src) const { dst.const_cast_derived() += src; }
|
pushq %rax
movq 0x8(%rsi), %rax
cmpq 0x28(%rdx), %rax
jne 0x578b3
movq (%rsi), %rcx
movq %rax, %rdi
testb $0x7, %cl
jne 0x57815
movl %ecx, %edi
shrl $0x3, %edi
andl $0x1, %edi
cmpq %rax, %rdi
cmovgeq %rax, %rdi
movsd 0x18(%rdx), %xmm0
movq 0x20(%rdx), %rdx
movq %rax, %r8
subq %rdi, %r8
movq %r8, %rsi
shrq $0x3f, %rsi
addq %r8, %rsi
andq $-0x2, %rsi
testq %rdi, %rdi
jle 0x5785c
xorl %r9d, %r9d
movsd (%rdx,%r9,8), %xmm1
mulsd %xmm0, %xmm1
movsd (%rcx,%r9,8), %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%rcx,%r9,8)
incq %r9
cmpq %r9, %rdi
jne 0x5783a
addq %rdi, %rsi
cmpq $0x2, %r8
jl 0x5788d
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movupd (%rdx,%rdi,8), %xmm2
mulpd %xmm1, %xmm2
movapd (%rcx,%rdi,8), %xmm3
subpd %xmm2, %xmm3
movapd %xmm3, (%rcx,%rdi,8)
addq $0x2, %rdi
cmpq %rsi, %rdi
jl 0x5786d
cmpq %rax, %rsi
jge 0x578b1
movsd (%rdx,%rsi,8), %xmm1
mulsd %xmm0, %xmm1
movsd (%rcx,%rsi,8), %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x57892
popq %rax
retq
leaq 0x5f88e(%rip), %rdi # 0xb7148
leaq 0x596d4(%rip), %rsi # 0xb0f95
leaq 0x779fe(%rip), %rcx # 0xcf2c6
movl $0x2f2, %edx # imm = 0x2F2
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
bool Eigen::RefBase<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>::construct<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, -1, false>>(Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, -1, false>&)
|
EIGEN_DEVICE_FUNC
inline ScalarWithConstIfNotLvalue* data() { return this->m_data; }
|
movq (%rsi), %r8
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movq 0x18(%rcx), %rcx
movq %r8, (%rdi)
movq %rax, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
testq %r8, %r8
sete %sil
movq %rdx, %r8
orq %rax, %r8
setns %r8b
orb %sil, %r8b
je 0x5791c
testq %rcx, %rcx
cmoveq %rax, %rcx
cmpq $0x1, %rdx
cmoveq %rax, %rcx
movq %rcx, 0x18(%rdi)
movb $0x1, %al
retq
pushq %rax
leaq 0x599b5(%rip), %rdi # 0xb12d9
leaq 0x59a58(%rip), %rsi # 0xb1383
leaq 0x76f2c(%rip), %rcx # 0xce85e
movl $0xb2, %edx
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/MapBase.h
|
Eigen::internal::triangular_solver_selector<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, 5, 0, -1>::run(Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const&, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>&)
|
static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
{
typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
const Index size = lhs.rows();
const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;
BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);
triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor, Rhs::InnerStrideAtCompileTime>
::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.innerStride(), rhs.outerStride(), blocking);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %r14
movq 0x10(%rsi), %r15
movq 0x8(%rsi), %rax
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movq %rax, (%rsi)
movq %r15, 0x8(%rsi)
leaq 0x20(%rsp), %r13
movq %r14, (%r13)
leaq 0x38(%rsp), %rdx
movq %r15, (%rdx)
movl $0x1, %ecx
movq %r13, %rdi
callq 0x58362
movq (%r13), %rax
movq -0x10(%r13), %rcx
imulq %rax, %rcx
movq %rcx, 0x8(%r13)
imulq -0x8(%r13), %rax
movq %rax, 0x10(%r13)
movq (%r12), %rdx
movq 0x18(%r12), %rcx
movq (%rbx), %r8
movq %rsp, %rax
movl $0x1, %r9d
movq %r14, %rdi
movq %r15, %rsi
pushq %rax
pushq 0x18(%rbx)
callq 0x57a4a
addq $0x10, %rsp
movq (%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rdi
callq 0x14720
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/SolveTriangular.h
|
Eigen::internal::triangular_solve_matrix<double, long, 1, 5, false, 0, 0, 1>::run(long, long, double const*, long, double*, long, long, Eigen::internal::level3_blocking<double, double>&)
|
EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>::run(
Index size, Index otherSize,
const Scalar* _tri, Index triStride,
Scalar* _other, Index otherIncr, Index otherStride,
level3_blocking<Scalar,Scalar>& blocking)
{
Index cols = otherSize;
typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> OtherMapper;
TriMapper tri(_tri, triStride);
OtherMapper other(_other, otherStride, otherIncr);
typedef gebp_traits<Scalar,Scalar> Traits;
enum {
SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
IsLower = (Mode&Lower) == Lower
};
Index kc = blocking.kc(); // cache block size along the K direction
Index mc = (std::min)(size,blocking.mc()); // cache block size along the M direction
std::size_t sizeA = kc*mc;
std::size_t sizeB = kc*cols;
ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
conj_if<Conjugate> conj;
gebp_kernel<Scalar, Scalar, Index, OtherMapper, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel;
gemm_pack_lhs<Scalar, Index, TriMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, TriStorageOrder> pack_lhs;
gemm_pack_rhs<Scalar, Index, OtherMapper, Traits::nr, ColMajor, false, true> pack_rhs;
// the goal here is to subdivise the Rhs panels such that we keep some cache
// coherence when accessing the rhs elements
std::ptrdiff_t l1, l2, l3;
manage_caching_sizes(GetAction, &l1, &l2, &l3);
Index subcols = cols>0 ? l2/(4 * sizeof(Scalar) * std::max<Index>(otherStride,size)) : 0;
subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr);
for(Index k2=IsLower ? 0 : size;
IsLower ? k2<size : k2>0;
IsLower ? k2+=kc : k2-=kc)
{
const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc);
// We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel,
// and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into
// A11 (the triangular part) and A21 the remaining rectangular part.
// Then the high level algorithm is:
// - B = R1 => general block copy (done during the next step)
// - R1 = A11^-1 B => tricky part
// - update B from the new R1 => actually this has to be performed continuously during the above step
// - R2 -= A21 * B => GEPP
// The tricky part: compute R1 = A11^-1 B while updating B from R1
// The idea is to split A11 into multiple small vertical panels.
// Each panel can be split into a small triangular part T1k which is processed without optimization,
// and the remaining small part T2k which is processed using gebp with appropriate block strides
for(Index j2=0; j2<cols; j2+=subcols)
{
Index actual_cols = (std::min)(cols-j2,subcols);
// for each small vertical panels [T1k^T, T2k^T]^T of lhs
for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth)
{
Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth);
// tr solve
for (Index k=0; k<actualPanelWidth; ++k)
{
// TODO write a small kernel handling this (can be shared with trsv)
Index i = IsLower ? k2+k1+k : k2-k1-k-1;
Index rs = actualPanelWidth - k - 1; // remaining size
Index s = TriStorageOrder==RowMajor ? (IsLower ? k2+k1 : i+1)
: IsLower ? i+1 : i-rs;
Scalar a = (Mode & UnitDiag) ? Scalar(1) : Scalar(1)/conj(tri(i,i));
for (Index j=j2; j<j2+actual_cols; ++j)
{
if (TriStorageOrder==RowMajor)
{
Scalar b(0);
const Scalar* l = &tri(i,s);
typename OtherMapper::LinearMapper r = other.getLinearMapper(s,j);
for (Index i3=0; i3<k; ++i3)
b += conj(l[i3]) * r(i3);
other(i,j) = (other(i,j) - b)*a;
}
else
{
Scalar& otherij = other(i,j);
otherij *= a;
Scalar b = otherij;
typename OtherMapper::LinearMapper r = other.getLinearMapper(s,j);
typename TriMapper::LinearMapper l = tri.getLinearMapper(s,i);
for (Index i3=0;i3<rs;++i3)
r(i3) -= b * conj(l(i3));
}
}
}
Index lengthTarget = actual_kc-k1-actualPanelWidth;
Index startBlock = IsLower ? k2+k1 : k2-k1-actualPanelWidth;
Index blockBOffset = IsLower ? k1 : lengthTarget;
// update the respective rows of B from other
pack_rhs(blockB+actual_kc*j2, other.getSubMapper(startBlock,j2), actualPanelWidth, actual_cols, actual_kc, blockBOffset);
// GEBP
if (lengthTarget>0)
{
Index startTarget = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc;
pack_lhs(blockA, tri.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
gebp_kernel(other.getSubMapper(startTarget,j2), blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1),
actualPanelWidth, actual_kc, 0, blockBOffset);
}
}
}
// R2 -= A21 * B => GEPP
{
Index start = IsLower ? k2+kc : 0;
Index end = IsLower ? size : k2-kc;
for(Index i2=start; i2<end; i2+=mc)
{
const Index actual_mc = (std::min)(mc,end-i2);
if (actual_mc>0)
{
pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2-kc), actual_kc, actual_mc);
gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0);
}
}
}
}
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rcx, -0xc0(%rbp)
movq %rdx, -0x130(%rbp)
cmpq $0x1, %r9
jne 0x581f8
movq 0x18(%rbp), %rbx
movq 0x10(%rbx), %rcx
movq 0x20(%rbx), %rax
cmpq %rdi, %rcx
movq %rdi, -0x68(%rbp)
cmovgeq %rdi, %rcx
movq %rcx, %r15
movq %rax, -0x60(%rbp)
imulq %rax, %r15
movq %r15, %rax
shrq $0x3d, %rax
jne 0x58217
movq %r8, %r14
movq %rsi, %r13
movq (%rbx), %rax
testq %rax, %rax
movq %rcx, -0xb0(%rbp)
je 0x57ac3
movq %rax, -0x58(%rbp)
xorl %r12d, %r12d
jmp 0x57b0a
leaq (,%r15,8), %rdi
cmpq $0x4000, %r15 # imm = 0x4000
ja 0x57aeb
movq %rsp, %r12
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %r12
movq %r12, %rsp
movq %r12, -0x58(%rbp)
jmp 0x57b0a
callq 0x147f0
movq %rax, %r12
testb $0xf, %r12b
jne 0x582ab
movq %r12, -0x58(%rbp)
testq %r12, %r12
je 0x582ad
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
movq -0x60(%rbp), %rcx
imulq %r13, %rcx
movq %rcx, -0xa0(%rbp)
cmpq %rax, %rcx
ja 0x58245
movq 0x8(%rbx), %rax
movq %rax, -0x88(%rbp)
testq %rax, %rax
je 0x57b40
xorl %ebx, %ebx
jmp 0x57b92
movq -0xa0(%rbp), %rax
leaq (,%rax,8), %rdi
cmpq $0x4000, %rax # imm = 0x4000
ja 0x57b71
movq %rsp, %rbx
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rbx
movq %rbx, %rsp
movq %rbx, -0x88(%rbp)
jmp 0x57b92
callq 0x147f0
movq %rax, %rbx
testb $0xf, %bl
jne 0x582b2
movq %rbx, -0x88(%rbp)
testq %rbx, %rbx
je 0x582d1
movq %r15, -0xf8(%rbp)
leaq 0xb9008(%rip), %rax # 0x110ba8
movb (%rax), %al
testb %al, %al
movq %r13, -0x90(%rbp)
movq %r12, -0xf0(%rbp)
movq %rbx, -0xe8(%rbp)
je 0x58273
movq 0x10(%rbp), %r15
testq %r13, %r13
jle 0x57bfb
leaq 0xb8fc1(%rip), %rax # 0x110b90
movq 0x8(%rax), %rax
movq -0x68(%rbp), %rsi
cmpq %rsi, %r15
movq %rsi, %rcx
cmovgq %r15, %rcx
shlq $0x5, %rcx
xorl %edx, %edx
divq %rcx
leaq 0x3(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
andq $-0x4, %rcx
jmp 0x57c01
xorl %ecx, %ecx
movq -0x68(%rbp), %rsi
cmpq $0x5, %rcx
movl $0x4, %eax
cmovlq %rax, %rcx
movq %rcx, -0xa8(%rbp)
testq %rsi, %rsi
movq -0xb0(%rbp), %rdx
jle 0x581b7
movq -0x130(%rbp), %rcx
leaq 0x8(%rcx), %rax
movq %rax, -0x128(%rbp)
movq -0xc0(%rbp), %rax
leaq 0x8(,%rax,8), %rdi
movq -0x60(%rbp), %rsi
movq %rsi, %r8
movq %rdi, -0x190(%rbp)
imulq %rdi, %r8
movq %r8, -0x158(%rbp)
movq %rax, %rdi
movq -0x68(%rbp), %rax
shlq $0x5, %rdi
addq $0x20, %rdi
movq %rdi, -0x178(%rbp)
leaq 0x8(%r14), %rdi
movq %rdi, -0x100(%rbp)
leaq (,%rsi,8), %rdi
movq %rdi, -0x150(%rbp)
movq %r15, %rdi
imulq -0xa8(%rbp), %rdi
shlq $0x3, %rdi
movq %rdi, -0x168(%rbp)
leaq (,%r15,8), %rbx
movq %rax, %rdi
subq %rsi, %rdi
movq %rdi, -0x118(%rbp)
leaq (%r14,%rsi,8), %rdi
movq %rdi, -0x110(%rbp)
leaq (,%rdx,8), %rdx
movq %rdx, -0x170(%rbp)
leaq (%rcx,%rsi,8), %rcx
movq %rcx, -0x108(%rbp)
movq $0x0, -0x70(%rbp)
movapd 0x583a1(%rip), %xmm2 # 0xb0090
movq %rax, -0x120(%rbp)
movq -0x60(%rbp), %rcx
movq -0x120(%rbp), %rdx
cmpq %rdx, %rcx
cmovlq %rcx, %rdx
movq %rdx, -0x160(%rbp)
movq %rax, %r9
subq -0x70(%rbp), %r9
cmpq %r9, %rcx
cmovlq %rcx, %r9
movq -0x90(%rbp), %rax
testq %rax, %rax
movq -0xa8(%rbp), %rcx
movq %r9, -0x78(%rbp)
jle 0x5803d
movq -0x100(%rbp), %rdx
movq %rdx, -0xb8(%rbp)
xorl %edx, %edx
movq %rdx, -0x80(%rbp)
subq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x98(%rbp)
cmovlq %rcx, %rax
movq %rax, -0xc8(%rbp)
testq %r9, %r9
jle 0x5800a
movq -0x80(%rbp), %rdx
movq -0xc8(%rbp), %rax
leaq (%rax,%rdx), %r13
movq %rdx, %rax
imulq %r9, %rax
movq -0x88(%rbp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, -0x148(%rbp)
movq %rdx, %rax
imulq %r15, %rax
leaq (%r14,%rax,8), %rax
movq %rax, -0x140(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x128(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x160(%rbp), %rcx
xorl %edx, %edx
movl $0x4, %eax
cmpq %rax, %rcx
movq %rcx, -0x188(%rbp)
cmovlq %rcx, %rax
cmpq $0x2, %rax
movl $0x1, %ecx
cmovlq %rcx, %rax
subq %rdx, %r9
cmpq $0x4, %r9
movl $0x4, %r12d
cmovlq %r9, %r12
movq -0x70(%rbp), %rcx
movq %rdx, -0xe0(%rbp)
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %r9, -0xd8(%rbp)
testq %r9, %r9
jle 0x57ea9
movq -0x138(%rbp), %rcx
movq -0xd0(%rbp), %rdx
xorl %esi, %esi
cmpq $0x0, -0x98(%rbp)
jle 0x57e96
movq -0x38(%rbp), %rdi
addq %rsi, %rdi
movq %rsi, %r8
notq %r8
addq %r12, %r8
movq %rcx, %r9
movq -0x80(%rbp), %r10
testq %r8, %r8
jle 0x57e8b
movq %r10, %r11
imulq %r15, %r11
leaq (%r14,%r11,8), %r11
movsd (%r11,%rdi,8), %xmm0
xorpd %xmm2, %xmm0
xorl %r11d, %r11d
movsd (%rdx,%r11,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r9,%r11,8), %xmm1
movsd %xmm1, (%r9,%r11,8)
incq %r11
cmpq %r8, %r11
jl 0x57e6d
incq %r10
addq %rbx, %r9
cmpq %r13, %r10
jl 0x57e50
incq %rsi
addq -0x190(%rbp), %rdx
addq $0x8, %rcx
cmpq %rax, %rsi
jne 0x57e2f
movq -0x140(%rbp), %rax
movq -0x38(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq %r15, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x39(%rbp), %rdi
movq -0x148(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %r12, %rcx
movq -0xc8(%rbp), %r8
movq -0x78(%rbp), %r9
pushq -0xe0(%rbp)
callq 0x586d0
addq $0x10, %rsp
movq -0xd8(%rbp), %r8
subq %r12, %r8
testq %r8, %r8
jle 0x57fc2
movq %r12, %rcx
movq -0x38(%rbp), %rsi
leaq (%r12,%rsi), %rdi
movq -0xc0(%rbp), %rdx
imulq %rdx, %rsi
movq -0x130(%rbp), %rax
leaq (%rax,%rsi,8), %rax
movq %rdi, -0x180(%rbp)
leaq (%rax,%rdi,8), %rax
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %r12
movq %r12, %rdx
movq %rcx, -0x38(%rbp)
movq %r8, -0xd8(%rbp)
xorl %r9d, %r9d
pushq $0x0
callq 0x40aca
addq $0x10, %rsp
movq -0x140(%rbp), %rax
movq -0x180(%rbp), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq %r15, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x2a(%rbp), %rdi
movq %r12, %rsi
movq -0x58(%rbp), %rdx
movq -0x148(%rbp), %rcx
movq -0xd8(%rbp), %r8
movq -0x38(%rbp), %r9
movsd 0x580da(%rip), %xmm0 # 0xb0080
pushq -0xe0(%rbp)
pushq $0x0
pushq -0x78(%rbp)
pushq %r9
pushq -0xc8(%rbp)
callq 0x40d48
addq $0x30, %rsp
movq -0xe0(%rbp), %rdx
addq $0x4, %rdx
movq -0x188(%rbp), %rcx
addq $-0x4, %rcx
movq -0xd0(%rbp), %rax
addq -0x178(%rbp), %rax
movq %rax, -0xd0(%rbp)
addq $0x20, -0x138(%rbp)
movq -0x78(%rbp), %r9
cmpq %r9, %rdx
movapd 0x5808c(%rip), %xmm2 # 0xb0090
jl 0x57dcc
movq -0xa8(%rbp), %rcx
movq -0x80(%rbp), %rdx
addq %rcx, %rdx
movq -0xb8(%rbp), %rax
addq -0x168(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x90(%rbp), %rax
cmpq %rax, %rdx
jl 0x57d48
movq -0x70(%rbp), %rdx
addq -0x60(%rbp), %rdx
movq -0x108(%rbp), %rdi
movq -0x110(%rbp), %r8
movq -0x118(%rbp), %r10
movq %rdx, %r13
movq -0x68(%rbp), %rax
movq %rdx, -0x70(%rbp)
cmpq %rax, %rdx
movq -0xb0(%rbp), %rcx
leaq -0x50(%rbp), %rdx
jge 0x581b7
movq %r10, %r12
subq %rcx, %r10
cmovgeq %rcx, %r12
testq %r12, %r12
jle 0x58151
movq %r10, -0x80(%rbp)
movq %r8, -0x98(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, -0x50(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x48(%rbp)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %r9, %rcx
movq %r12, %r8
xorl %r9d, %r9d
pushq $0x0
callq 0x40aca
addq $0x10, %rsp
movq -0x98(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %r15, -0x48(%rbp)
subq $0x30, %rsp
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rsp)
movq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq -0x90(%rbp), %rax
movq %rax, (%rsp)
leaq -0x2a(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x88(%rbp), %rcx
movq %r12, %r8
movq -0x78(%rbp), %r9
movsd 0x57f5b(%rip), %xmm0 # 0xb0080
callq 0x40d48
addq $0x30, %rsp
movq -0x68(%rbp), %rax
movapd 0x57f56(%rip), %xmm2 # 0xb0090
leaq -0x50(%rbp), %rdx
movq -0x78(%rbp), %r9
movq -0x38(%rbp), %rdi
movq -0x98(%rbp), %r8
movq -0x80(%rbp), %r10
movq -0xb0(%rbp), %rcx
addq %rcx, %r13
movq -0x170(%rbp), %rsi
addq %rsi, %r8
addq %rsi, %rdi
cmpq %rax, %r13
jl 0x58079
movq -0x60(%rbp), %rcx
subq %rcx, -0x120(%rbp)
movq -0x158(%rbp), %rdx
addq %rdx, -0x128(%rbp)
movq -0x150(%rbp), %rsi
addq %rsi, -0x100(%rbp)
subq %rcx, -0x118(%rbp)
addq %rsi, -0x110(%rbp)
addq %rdx, -0x108(%rbp)
cmpq %rax, -0x70(%rbp)
jl 0x57cf6
cmpq $0x4001, -0xa0(%rbp) # imm = 0x4001
jb 0x581d0
movq -0xe8(%rbp), %rdi
callq 0x14720
cmpq $0x4001, -0xf8(%rbp) # imm = 0x4001
movq -0xf0(%rbp), %rdi
jb 0x581e9
callq 0x14720
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a609(%rip), %rdi # 0xb2808
leaq 0x5a60a(%rip), %rsi # 0xb2810
leaq 0x5ae63(%rip), %rcx # 0xb3070
movl $0xae, %edx
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xb7d10(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb7d62(%rip), %rsi # 0x10ff98
movq 0xb7ccb(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movl $0x8, %edi
callq 0x14290
movq 0xb7ce2(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb7d34(%rip), %rsi # 0x10ff98
movq 0xb7c9d(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0xb892e(%rip), %rdi # 0x110ba8
callq 0x14af0
testl %eax, %eax
je 0x57bbf
leaq 0xb8902(%rip), %rdi # 0x110b90
callq 0x40068
leaq 0xb890e(%rip), %rdi # 0x110ba8
callq 0x143a0
movq -0x90(%rbp), %r13
jmp 0x57bbf
jmp 0x582b2
jmp 0x58217
leaq 0x58b52(%rip), %rdi # 0xb0e0b
leaq 0x58c06(%rip), %rsi # 0xb0ec6
leaq 0x58c6c(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xb7c56(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb7ca8(%rip), %rsi # 0x10ff98
movq 0xb7c11(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movq %rax, %rbx
leaq 0xb889f(%rip), %rdi # 0x110ba8
callq 0x14390
jmp 0x58322
jmp 0x58312
movq %rax, %rbx
jmp 0x58349
jmp 0x5831f
jmp 0x5831f
jmp 0x5831f
jmp 0x5831f
movq %rax, %rbx
cmpq $0x4001, -0xa0(%rbp) # imm = 0x4001
movq -0xf8(%rbp), %r15
movq -0xf0(%rbp), %r12
jb 0x58349
movq -0xe8(%rbp), %rdi
callq 0x14720
cmpq $0x4001, %r15 # imm = 0x4001
jb 0x5835a
movq %r12, %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/products/TriangularSolverMatrix.h
|
void Eigen::internal::evaluateProductBlockingSizesHeuristic<double, double, 4, long>(long&, long&, long&, long)
|
void evaluateProductBlockingSizesHeuristic(Index& k, Index& m, Index& n, Index num_threads = 1)
{
typedef gebp_traits<LhsScalar,RhsScalar> Traits;
// Explanations:
// Let's recall that the product algorithms form mc x kc vertical panels A' on the lhs and
// kc x nc blocks B' on the rhs. B' has to fit into L2/L3 cache. Moreover, A' is processed
// per mr x kc horizontal small panels where mr is the blocking size along the m dimension
// at the register level. This small horizontal panel has to stay within L1 cache.
std::ptrdiff_t l1, l2, l3;
manage_caching_sizes(GetAction, &l1, &l2, &l3);
#ifdef EIGEN_VECTORIZE_AVX512
// We need to find a rationale for that, but without this adjustment,
// performance with AVX512 is pretty bad, like -20% slower.
// One reason is that with increasing packet-size, the blocking size k
// has to become pretty small if we want that 1 lhs panel fit within L1.
// For instance, with the 3pX4 kernel and double, the size of the lhs+rhs panels are:
// k*(3*64 + 4*8) Bytes, with l1=32kBytes, and k%8=0, we have k=144.
// This is quite small for a good reuse of the accumulation registers.
l1 *= 4;
#endif
if (num_threads > 1) {
typedef typename Traits::ResScalar ResScalar;
enum {
kdiv = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
ksub = Traits::mr * Traits::nr * sizeof(ResScalar),
kr = 8,
mr = Traits::mr,
nr = Traits::nr
};
// Increasing k gives us more time to prefetch the content of the "C"
// registers. However once the latency is hidden there is no point in
// increasing the value of k, so we'll cap it at 320 (value determined
// experimentally).
// To avoid that k vanishes, we make k_cache at least as big as kr
const Index k_cache = numext::maxi<Index>(kr, (numext::mini<Index>)((l1-ksub)/kdiv, 320));
if (k_cache < k) {
k = k_cache - (k_cache % kr);
eigen_internal_assert(k > 0);
}
const Index n_cache = (l2-l1) / (nr * sizeof(RhsScalar) * k);
const Index n_per_thread = numext::div_ceil(n, num_threads);
if (n_cache <= n_per_thread) {
// Don't exceed the capacity of the l2 cache.
eigen_internal_assert(n_cache >= static_cast<Index>(nr));
n = n_cache - (n_cache % nr);
eigen_internal_assert(n > 0);
} else {
n = (numext::mini<Index>)(n, (n_per_thread + nr - 1) - ((n_per_thread + nr - 1) % nr));
}
if (l3 > l2) {
// l3 is shared between all cores, so we'll give each thread its own chunk of l3.
const Index m_cache = (l3-l2) / (sizeof(LhsScalar) * k * num_threads);
const Index m_per_thread = numext::div_ceil(m, num_threads);
if(m_cache < m_per_thread && m_cache >= static_cast<Index>(mr)) {
m = m_cache - (m_cache % mr);
eigen_internal_assert(m > 0);
} else {
m = (numext::mini<Index>)(m, (m_per_thread + mr - 1) - ((m_per_thread + mr - 1) % mr));
}
}
}
else {
// In unit tests we do not want to use extra large matrices,
// so we reduce the cache size to check the blocking strategy is not flawed
#ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
l1 = 9*1024;
l2 = 32*1024;
l3 = 512*1024;
#endif
// Early return for small problems because the computation below are time consuming for small problems.
// Perhaps it would make more sense to consider k*n*m??
// Note that for very tiny problem, this function should be bypassed anyway
// because we use the coefficient-based implementation for them.
if((numext::maxi)(k,(numext::maxi)(m,n))<48)
return;
typedef typename Traits::ResScalar ResScalar;
enum {
k_peeling = 8,
k_div = KcFactor * (Traits::mr * sizeof(LhsScalar) + Traits::nr * sizeof(RhsScalar)),
k_sub = Traits::mr * Traits::nr * sizeof(ResScalar)
};
// ---- 1st level of blocking on L1, yields kc ----
// Blocking on the third dimension (i.e., k) is chosen so that an horizontal panel
// of size mr x kc of the lhs plus a vertical panel of kc x nr of the rhs both fits within L1 cache.
// We also include a register-level block of the result (mx x nr).
// (In an ideal world only the lhs panel would stay in L1)
// Moreover, kc has to be a multiple of 8 to be compatible with loop peeling, leading to a maximum blocking size of:
const Index max_kc = numext::maxi<Index>(((l1-k_sub)/k_div) & (~(k_peeling-1)),1);
const Index old_k = k;
if(k>max_kc)
{
// We are really blocking on the third dimension:
// -> reduce blocking size to make sure the last block is as large as possible
// while keeping the same number of sweeps over the result.
k = (k%max_kc)==0 ? max_kc
: max_kc - k_peeling * ((max_kc-1-(k%max_kc))/(k_peeling*(k/max_kc+1)));
eigen_internal_assert(((old_k/k) == (old_k/max_kc)) && "the number of sweeps has to remain the same");
}
// ---- 2nd level of blocking on max(L2,L3), yields nc ----
// TODO find a reliable way to get the actual amount of cache per core to use for 2nd level blocking, that is:
// actual_l2 = max(l2, l3/nb_core_sharing_l3)
// The number below is quite conservative: it is better to underestimate the cache size rather than overestimating it)
// For instance, it corresponds to 6MB of L3 shared among 4 cores.
#ifdef EIGEN_DEBUG_SMALL_PRODUCT_BLOCKS
const Index actual_l2 = l3;
#else
const Index actual_l2 = 1572864; // == 1.5 MB
#endif
// Here, nc is chosen such that a block of kc x nc of the rhs fit within half of L2.
// The second half is implicitly reserved to access the result and lhs coefficients.
// When k<max_kc, then nc can arbitrarily growth. In practice, it seems to be fruitful
// to limit this growth: we bound nc to growth by a factor x1.5.
// However, if the entire lhs block fit within L1, then we are not going to block on the rows at all,
// and it becomes fruitful to keep the packed rhs blocks in L1 if there is enough remaining space.
Index max_nc;
const Index lhs_bytes = m * k * sizeof(LhsScalar);
const Index remaining_l1 = l1- k_sub - lhs_bytes;
if(remaining_l1 >= Index(Traits::nr*sizeof(RhsScalar))*k)
{
// L1 blocking
max_nc = remaining_l1 / (k*sizeof(RhsScalar));
}
else
{
// L2 blocking
max_nc = (3*actual_l2)/(2*2*max_kc*sizeof(RhsScalar));
}
// WARNING Below, we assume that Traits::nr is a power of two.
Index nc = numext::mini<Index>(actual_l2/(2*k*sizeof(RhsScalar)), max_nc) & (~(Traits::nr-1));
if(n>nc)
{
// We are really blocking over the columns:
// -> reduce blocking size to make sure the last block is as large as possible
// while keeping the same number of sweeps over the packed lhs.
// Here we allow one more sweep if this gives us a perfect match, thus the commented "-1"
n = (n%nc)==0 ? nc
: (nc - Traits::nr * ((nc/*-1*/-(n%nc))/(Traits::nr*(n/nc+1))));
}
else if(old_k==k)
{
// So far, no blocking at all, i.e., kc==k, and nc==n.
// In this case, let's perform a blocking over the rows such that the packed lhs data is kept in cache L1/L2
// TODO: part of this blocking strategy is now implemented within the kernel itself, so the L1-based heuristic here should be obsolete.
Index problem_size = k*n*sizeof(LhsScalar);
Index actual_lm = actual_l2;
Index max_mc = m;
if(problem_size<=1024)
{
// problem is small enough to keep in L1
// Let's choose m such that lhs's block fit in 1/3 of L1
actual_lm = l1;
}
else if(l3!=0 && problem_size<=32768)
{
// we have both L2 and L3, and problem is small enough to be kept in L2
// Let's choose m such that lhs's block fit in 1/3 of L2
actual_lm = l2;
max_mc = (numext::mini<Index>)(576,max_mc);
}
Index mc = (numext::mini<Index>)(actual_lm/(3*k*sizeof(LhsScalar)), max_mc);
if (mc > Traits::mr) mc -= mc % Traits::mr;
else if (mc==0) return;
m = (m%mc)==0 ? mc
: (mc - Traits::mr * ((mc/*-1*/-(m%mc))/(Traits::mr*(m/mc+1))));
}
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xb882b(%rip), %rax # 0x110ba8
movb (%rax), %al
testb %al, %al
je 0x58688
leaq 0xb8802(%rip), %rax # 0x110b90
movq (%rax), %rsi
movq 0x8(%rax), %r11
movq 0x10(%rax), %rcx
cmpq $0x2, %r12
jl 0x58437
leaq -0x80(%rsi), %rax
leaq 0x7f(%rsi), %rdx
testq %rax, %rax
cmovnsq %rax, %rdx
sarq $0x8, %rdx
movl $0x140, %eax # imm = 0x140
cmpq %rax, %rdx
cmovgeq %rax, %rdx
cmpq $0x9, %rdx
movl $0x8, %eax
cmovgeq %rdx, %rax
movq (%r15), %rdi
cmpq %rdi, %rax
jge 0x583ee
movabsq $0x7ffffffffffffffc, %rdx # imm = 0x7FFFFFFFFFFFFFFC
addq $-0x4, %rdx
andq %rdx, %rax
movq %rax, (%r15)
movq %rax, %rdi
movq %r11, %rax
subq %rsi, %rax
shlq $0x5, %rdi
xorl %edx, %edx
divq %rdi
movq %rax, %rsi
movq (%r14), %rdi
leaq (%r12,%rdi), %rax
decq %rax
cqto
idivq %r12
cmpq %rax, %rsi
jle 0x584e0
leaq 0x3(%rax), %rdx
addq $0x6, %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
andq $-0x4, %rax
cmpq %rdi, %rax
cmovgeq %rdi, %rax
jmp 0x584ef
movq (%rbx), %r8
movq (%r14), %rax
cmpq %rax, %r8
cmovgq %r8, %rax
movq (%r15), %rdi
cmpq %rax, %rdi
cmovgq %rdi, %rax
cmpq $0x30, %rax
jl 0x5867c
leaq -0x80(%rsi), %r9
leaq 0x7f(%rsi), %rax
testq %r9, %r9
cmovnsq %r9, %rax
sarq $0x8, %rax
andq $-0x8, %rax
cmpq $0x2, %rax
movl $0x1, %r10d
cmovgeq %rax, %r10
movq %rdi, %r12
cmpq %r10, %rdi
jle 0x584bb
movq %rdi, %rax
xorl %edx, %edx
divq %r10
movq %r10, %r12
testq %rdx, %rdx
je 0x584b5
notq %rdx
addq %r10, %rdx
leaq 0x8(,%rax,8), %r8
movq %rdx, %rax
cqto
idivq %r8
shlq $0x3, %rax
movq %r10, %r12
subq %rax, %r12
movq %r12, (%r15)
movq (%rbx), %r8
movq %r8, %rax
imulq %r12, %rax
shlq $0x3, %rax
subq %rax, %r9
movq %r12, %rax
shlq $0x5, %rax
cmpq %rax, %r9
jge 0x58549
shlq $0x5, %r10
movl $0x480000, %eax # imm = 0x480000
jmp 0x58554
leaq 0x3(%rsi), %rax
testq %rsi, %rsi
cmovnsq %rsi, %rax
andq $-0x4, %rax
movq %rax, (%r14)
subq %r11, %rcx
jle 0x5867c
leaq -0x1(%r12), %rsi
movq (%r15), %rdi
imulq %r12, %rdi
shlq $0x3, %rdi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %rcx
movq (%rbx), %rdi
addq %rdi, %rsi
movq %rsi, %rax
cqto
idivq %r12
cmpq %rax, %rcx
setge %dl
cmpq $0x4, %rcx
setl %sil
orb %dl, %sil
jne 0x585b2
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
andq %rax, %rcx
jmp 0x58679
leaq (,%r12,8), %r10
movq %r9, %rax
xorl %edx, %edx
divq %r10
movq %rax, %r10
movq %r12, %r9
shlq $0x4, %r9
movl $0x180000, %eax # imm = 0x180000
xorl %edx, %edx
divq %r9
movq %rax, %r9
cmpq %rax, %r10
cmovlq %r10, %r9
andq $-0x4, %r9
movq (%r14), %rax
cmpq %r9, %rax
jle 0x585d4
cqto
idivq %r9
testq %rdx, %rdx
je 0x585aa
movq %r9, %rcx
subq %rdx, %rcx
leaq 0x4(,%rax,4), %rsi
movq %rcx, %rax
cqto
idivq %rsi
shlq $0x2, %rax
subq %rax, %r9
movq %r9, (%r14)
jmp 0x5867c
leaq 0x3(%rax), %rcx
addq $0x6, %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
andq $-0x4, %rax
cmpq %rdi, %rax
cmovgeq %rdi, %rax
movq %rax, (%rbx)
jmp 0x5867c
cmpq %r12, %rdi
jne 0x5867c
imulq %rdi, %rax
shlq $0x3, %rax
movq %r8, %r9
cmpq $0x401, %rax # imm = 0x401
jl 0x5861b
testq %rcx, %rcx
sete %cl
cmpq $0x8001, %rax # imm = 0x8001
setae %al
movl $0x180000, %esi # imm = 0x180000
orb %cl, %al
movq %r8, %r9
jne 0x5861b
movl $0x240, %r9d # imm = 0x240
cmpq %r9, %r8
cmovlq %r8, %r9
movq %r11, %rsi
shlq $0x3, %rdi
leaq (%rdi,%rdi,2), %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
cmpq %rax, %r9
cmovlq %r9, %rcx
cmpq $0x5, %rcx
jl 0x5864a
movabsq $0x7ffffffffffffffc, %rax # imm = 0x7FFFFFFFFFFFFFFC
andq %rax, %rcx
jmp 0x5864f
testq %rcx, %rcx
je 0x5867c
movq %r8, %rax
cqto
idivq %rcx
testq %rdx, %rdx
je 0x58679
movq %rcx, %rsi
subq %rdx, %rsi
leaq 0x4(,%rax,4), %rdi
movq %rsi, %rax
cqto
idivq %rdi
shlq $0x2, %rax
subq %rax, %rcx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xb8519(%rip), %rdi # 0x110ba8
callq 0x14af0
testl %eax, %eax
je 0x58387
leaq 0xb84ed(%rip), %rdi # 0x110b90
callq 0x40068
leaq 0xb84f9(%rip), %rdi # 0x110ba8
callq 0x143a0
jmp 0x58387
movq %rax, %rbx
leaq 0xb84e5(%rip), %rdi # 0x110ba8
callq 0x14390
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
|
Eigen::internal::gemm_pack_rhs<double, long, Eigen::internal::blas_data_mapper<double, long, 0, 0, 1>, 4, 0, false, true>::operator()(double*, Eigen::internal::blas_data_mapper<double, long, 0, 0, 1> const&, long, long, long, long)
|
EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, ColMajor, Conjugate, PanelMode>
::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
{
EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS COLMAJOR");
EIGEN_UNUSED_VARIABLE(stride);
EIGEN_UNUSED_VARIABLE(offset);
eigen_assert(((!PanelMode) && stride==0 && offset==0) || (PanelMode && stride>=depth && offset<=stride));
conj_if<NumTraits<Scalar>::IsComplex && Conjugate> cj;
Index packet_cols8 = nr>=8 ? (cols/8) * 8 : 0;
Index packet_cols4 = nr>=4 ? (cols/4) * 4 : 0;
Index count = 0;
const Index peeled_k = (depth/PacketSize)*PacketSize;
// if(nr>=8)
// {
// for(Index j2=0; j2<packet_cols8; j2+=8)
// {
// // skip what we have before
// if(PanelMode) count += 8 * offset;
// const Scalar* b0 = &rhs[(j2+0)*rhsStride];
// const Scalar* b1 = &rhs[(j2+1)*rhsStride];
// const Scalar* b2 = &rhs[(j2+2)*rhsStride];
// const Scalar* b3 = &rhs[(j2+3)*rhsStride];
// const Scalar* b4 = &rhs[(j2+4)*rhsStride];
// const Scalar* b5 = &rhs[(j2+5)*rhsStride];
// const Scalar* b6 = &rhs[(j2+6)*rhsStride];
// const Scalar* b7 = &rhs[(j2+7)*rhsStride];
// Index k=0;
// if(PacketSize==8) // TODO enable vectorized transposition for PacketSize==4
// {
// for(; k<peeled_k; k+=PacketSize) {
// PacketBlock<Packet> kernel;
// for (int p = 0; p < PacketSize; ++p) {
// kernel.packet[p] = ploadu<Packet>(&rhs[(j2+p)*rhsStride+k]);
// }
// ptranspose(kernel);
// for (int p = 0; p < PacketSize; ++p) {
// pstoreu(blockB+count, cj.pconj(kernel.packet[p]));
// count+=PacketSize;
// }
// }
// }
// for(; k<depth; k++)
// {
// blockB[count+0] = cj(b0[k]);
// blockB[count+1] = cj(b1[k]);
// blockB[count+2] = cj(b2[k]);
// blockB[count+3] = cj(b3[k]);
// blockB[count+4] = cj(b4[k]);
// blockB[count+5] = cj(b5[k]);
// blockB[count+6] = cj(b6[k]);
// blockB[count+7] = cj(b7[k]);
// count += 8;
// }
// // skip what we have after
// if(PanelMode) count += 8 * (stride-offset-depth);
// }
// }
if(nr>=4)
{
for(Index j2=packet_cols8; j2<packet_cols4; j2+=4)
{
// skip what we have before
if(PanelMode) count += 4 * offset;
const LinearMapper dm0 = rhs.getLinearMapper(0, j2 + 0);
const LinearMapper dm1 = rhs.getLinearMapper(0, j2 + 1);
const LinearMapper dm2 = rhs.getLinearMapper(0, j2 + 2);
const LinearMapper dm3 = rhs.getLinearMapper(0, j2 + 3);
Index k=0;
if((PacketSize%4)==0) // TODO enable vectorized transposition for PacketSize==2 ??
{
for(; k<peeled_k; k+=PacketSize) {
PacketBlock<Packet,(PacketSize%4)==0?4:PacketSize> kernel;
kernel.packet[0 ] = dm0.template loadPacket<Packet>(k);
kernel.packet[1%PacketSize] = dm1.template loadPacket<Packet>(k);
kernel.packet[2%PacketSize] = dm2.template loadPacket<Packet>(k);
kernel.packet[3%PacketSize] = dm3.template loadPacket<Packet>(k);
ptranspose(kernel);
pstoreu(blockB+count+0*PacketSize, cj.pconj(kernel.packet[0]));
pstoreu(blockB+count+1*PacketSize, cj.pconj(kernel.packet[1%PacketSize]));
pstoreu(blockB+count+2*PacketSize, cj.pconj(kernel.packet[2%PacketSize]));
pstoreu(blockB+count+3*PacketSize, cj.pconj(kernel.packet[3%PacketSize]));
count+=4*PacketSize;
}
}
for(; k<depth; k++)
{
blockB[count+0] = cj(dm0(k));
blockB[count+1] = cj(dm1(k));
blockB[count+2] = cj(dm2(k));
blockB[count+3] = cj(dm3(k));
count += 4;
}
// skip what we have after
if(PanelMode) count += 4 * (stride-offset-depth);
}
}
// copy the remaining columns one at a time (nr==1)
for(Index j2=packet_cols4; j2<cols; ++j2)
{
if(PanelMode) count += offset;
const LinearMapper dm0 = rhs.getLinearMapper(0, j2);
for(Index k=0; k<depth; k++)
{
blockB[count] = cj(dm0(k));
count += 1;
}
if(PanelMode) count += (stride-offset-depth);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq %rcx, %r9
jl 0x58865
movq %rcx, %rbx
movq 0x60(%rsp), %rcx
cmpq %r9, %rcx
jg 0x58865
movq %rsi, (%rsp)
leaq 0x3(%r8), %rdi
testq %r8, %r8
cmovnsq %r8, %rdi
movq %rdi, %r10
andq $-0x4, %r10
movq %r8, 0x10(%rsp)
cmpq $0x4, %r8
movq %r9, 0x18(%rsp)
movq %rdx, 0x8(%rsp)
jl 0x587e8
leaq (,%rcx,4), %r8
movq (%rdx), %r14
movq 0x8(%rdx), %r15
movq %r9, %r12
subq %rbx, %r12
subq %rcx, %r12
shlq $0x2, %r12
leaq (%r15,%r15,2), %rax
leaq (%r14,%rax,8), %r13
movq %r15, %rbp
shlq $0x5, %rbp
leaq (%r14,%r15,8), %rax
shlq $0x4, %r15
addq %r14, %r15
shlq $0x5, %rcx
movq (%rsp), %rdx
addq %rdx, %rcx
addq $0x18, %rcx
movq %rcx, 0x20(%rsp)
xorl %edx, %edx
xorl %ecx, %ecx
leaq (%rcx,%r8), %r11
testq %rbx, %rbx
jle 0x587cb
movq 0x20(%rsp), %rsi
leaq (%rsi,%rcx,8), %r9
xorl %esi, %esi
movq %rbx, %rcx
movsd (%r14,%rsi,2), %xmm0
movsd %xmm0, -0x18(%r9,%rsi,8)
movsd (%rax,%rsi,2), %xmm0
movsd %xmm0, -0x10(%r9,%rsi,8)
movsd (%r15,%rsi,2), %xmm0
movsd %xmm0, -0x8(%r9,%rsi,8)
movsd (%r13,%rsi,2), %xmm0
movsd %xmm0, (%r9,%rsi,8)
addq $0x4, %rsi
decq %rcx
jne 0x5878c
addq %rsi, %r11
addq %r12, %r11
addq $0x4, %rdx
addq %rbp, %r13
addq %rbp, %r15
addq %rbp, %rax
addq %rbp, %r14
movq %r11, %rcx
cmpq %r10, %rdx
jl 0x58775
jmp 0x587eb
xorl %r11d, %r11d
movq 0x10(%rsp), %r8
cmpq %r8, %r10
movq 0x18(%rsp), %rsi
movq (%rsp), %r9
movq 0x60(%rsp), %r14
jge 0x58856
sarq $0x2, %rdi
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rax
subq %rbx, %rsi
subq %r14, %rsi
imulq %rax, %rdi
shlq $0x5, %rdi
addq (%rdx), %rdi
shlq $0x3, %rax
addq %r14, %r11
testq %rbx, %rbx
jle 0x58848
leaq (%r9,%r11,8), %rdx
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0x58833
addq %rcx, %r11
addq %rsi, %r11
incq %r10
addq %rax, %rdi
cmpq %r8, %r10
jne 0x58825
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5a8b0(%rip), %rdi # 0xb311c
leaq 0x5a904(%rip), %rsi # 0xb3177
leaq 0x77353(%rip), %rcx # 0xcfbcd
movl $0x958, %edx # imm = 0x958
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralBlockPanelKernel.h
|
void Eigen::internal::generic_product_impl<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::DenseShape, Eigen::DenseShape, 8>::subTo<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>(Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>&, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const&, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const&)
|
static void subTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
{
if((rhs.rows()+dst.rows()+dst.cols())<EIGEN_GEMM_TO_COEFFBASED_THRESHOLD && rhs.rows()>0)
lazyproduct::eval_dynamic(dst, lhs, rhs, internal::sub_assign_op<typename Dst::Scalar,Scalar>());
else
scaleAndAddTo(dst, lhs, rhs, Scalar(-1));
}
|
subq $0x88, %rsp
movq 0x8(%rdx), %rax
testq %rax, %rax
jle 0x58933
movq 0x8(%rdi), %r8
movq 0x10(%rdi), %rcx
leaq (%r8,%rax), %r9
addq %rcx, %r9
cmpq $0x13, %r9
jg 0x58933
cmpq %rax, 0x10(%rsi)
jne 0x58952
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq (%rsi), %r9
movq %r9, 0x18(%rsp)
movq 0x18(%rsi), %r9
movq %r9, 0x28(%rsp)
movq (%rdx), %r9
movq %r9, 0x30(%rsp)
movq 0x18(%rdx), %r9
movq %r9, 0x40(%rsp)
movq %rax, 0x48(%rsp)
cmpq 0x8(%rsi), %r8
jne 0x58971
cmpq 0x10(%rdx), %rcx
jne 0x58971
movq (%rdi), %rax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
movq 0x18(%rdi), %rax
movq %rax, 0x10(%rcx)
leaq 0x68(%rsp), %rax
movq %rcx, (%rax)
leaq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0x7(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rdi, 0x18(%rax)
movq %rax, %rdi
callq 0x58c3c
jmp 0x5894a
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
callq 0x58990
addq $0x88, %rsp
retq
leaq 0x591b4(%rip), %rdi # 0xb1b0d
leaq 0x59239(%rip), %rsi # 0xb1b99
leaq 0x78047(%rip), %rcx # 0xd09ae
movl $0x62, %edx
callq 0x143c0
leaq 0x5e7d0(%rip), %rdi # 0xb7148
leaq 0x58616(%rip), %rsi # 0xb0f95
leaq 0x776fa(%rip), %rcx # 0xd0080
movl $0x2f2, %edx # imm = 0x2F2
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h
|
void Eigen::internal::generic_product_impl<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::DenseShape, Eigen::DenseShape, 8>::scaleAndAddTo<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>(Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>&, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const&, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const&, double const&)
|
static void scaleAndAddTo(Dest& dst, const Lhs& a_lhs, const Rhs& a_rhs, const Scalar& alpha)
{
eigen_assert(dst.rows()==a_lhs.rows() && dst.cols()==a_rhs.cols());
if(a_lhs.cols()==0 || a_lhs.rows()==0 || a_rhs.cols()==0)
return;
if (dst.cols() == 1)
{
// Fallback to GEMV if either the lhs or rhs is a runtime vector
typename Dest::ColXpr dst_vec(dst.col(0));
return internal::generic_product_impl<Lhs,typename Rhs::ConstColXpr,DenseShape,DenseShape,GemvProduct>
::scaleAndAddTo(dst_vec, a_lhs, a_rhs.col(0), alpha);
}
else if (dst.rows() == 1)
{
// Fallback to GEMV if either the lhs or rhs is a runtime vector
typename Dest::RowXpr dst_vec(dst.row(0));
return internal::generic_product_impl<typename Lhs::ConstRowXpr,Rhs,DenseShape,DenseShape,GemvProduct>
::scaleAndAddTo(dst_vec, a_lhs.row(0), a_rhs, alpha);
}
typename internal::add_const_on_value_type<ActualLhsType>::type lhs = LhsBlasTraits::extract(a_lhs);
typename internal::add_const_on_value_type<ActualRhsType>::type rhs = RhsBlasTraits::extract(a_rhs);
Scalar actualAlpha = combine_scalar_factors(alpha, a_lhs, a_rhs);
typedef internal::gemm_blocking_space<(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,LhsScalar,RhsScalar,
Dest::MaxRowsAtCompileTime,Dest::MaxColsAtCompileTime,MaxDepthAtCompileTime> BlockingType;
typedef internal::gemm_functor<
Scalar, Index,
internal::general_matrix_matrix_product<
Index,
LhsScalar, (ActualLhsTypeCleaned::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(LhsBlasTraits::NeedToConjugate),
RhsScalar, (ActualRhsTypeCleaned::Flags&RowMajorBit) ? RowMajor : ColMajor, bool(RhsBlasTraits::NeedToConjugate),
(Dest::Flags&RowMajorBit) ? RowMajor : ColMajor,
Dest::InnerStrideAtCompileTime>,
ActualLhsTypeCleaned, ActualRhsTypeCleaned, Dest, BlockingType> GemmFunctor;
BlockingType blocking(dst.rows(), dst.cols(), lhs.cols(), 1, true);
internal::parallelize_gemm<(Dest::MaxRowsAtCompileTime>32 || Dest::MaxRowsAtCompileTime==Dynamic)>
(GemmFunctor(lhs, rhs, dst, actualAlpha, blocking), a_lhs.rows(), a_rhs.cols(), a_lhs.cols(), Dest::Flags&RowMajorBit);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x58b9a
movq %rdi, %r15
movq 0x10(%rdi), %rdi
cmpq 0x10(%rbx), %rdi
jne 0x58b9a
testq %rdi, %rdi
je 0x58b8e
testq %rdx, %rdx
je 0x58b8e
movq %rsi, %r14
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x58b8e
cmpq $0x1, %rdi
jne 0x58a6d
movq (%r15), %rsi
movq 0x18(%r15), %rax
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rsi, %rsi
sete %sil
testq %rdx, %rdx
setns %dl
orb %sil, %dl
je 0x58bb9
movq %r15, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movq 0x18(%rbx), %rax
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
movq %rdx, 0x40(%rsp)
movq %rsi, 0x48(%rsp)
testq %rdx, %rdx
sete %dl
testq %rsi, %rsi
setns %sil
orb %dl, %sil
je 0x58bd0
leaq 0x40(%rsp), %rdx
movq %rbx, 0x18(%rdx)
movups %xmm0, 0x20(%rdx)
movq %rax, 0x30(%rdx)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x58fde
jmp 0x58b8e
cmpq $0x1, %rdx
jne 0x58af1
movq (%r15), %rdx
movq %rdx, (%rsp)
movq %rdi, 0x10(%rsp)
testq %rdx, %rdx
sete %dl
testq %rdi, %rdi
setns %sil
orb %dl, %sil
je 0x58be7
movq %r15, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsp)
movq $0x1, 0x30(%rsp)
movq (%r14), %rdx
movq %rdx, 0x40(%rsp)
movq %rax, 0x50(%rsp)
testq %rdx, %rdx
sete %dl
testq %rax, %rax
setns %al
orb %dl, %al
je 0x58bfe
leaq 0x40(%rsp), %rsi
movq %r14, 0x18(%rsi)
movups %xmm0, 0x20(%rsi)
movq $0x1, 0x30(%rsi)
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x5914c
jmp 0x58b8e
movsd (%rcx), %xmm0
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movq %rdx, (%rsi)
leaq 0x18(%rsp), %rdx
movq %rdi, (%rdx)
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movl $0x1, %ecx
movq %r12, %rdi
callq 0x3fcfa
movq (%r12), %rax
movq -0x10(%r12), %rcx
imulq %rax, %rcx
movq %rcx, 0x8(%r12)
imulq -0x8(%r12), %rax
movq %rax, 0x10(%r12)
leaq 0x40(%rsp), %rdi
movq %r14, (%rdi)
movq %rbx, 0x8(%rdi)
movq %r15, 0x10(%rdi)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rdi)
movq %rsp, %rax
movq %rax, 0x20(%rdi)
movq 0x8(%r14), %rdx
movq 0x10(%rbx), %r8
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x5948a
movq (%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rdi
callq 0x14720
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5944f(%rip), %rdi # 0xb1ff0
leaq 0x5947d(%rip), %rsi # 0xb2025
leaq 0x77ef9(%rip), %rcx # 0xd0aa8
movl $0x1d6, %edx # imm = 0x1D6
callq 0x143c0
leaq 0x58719(%rip), %rdi # 0xb12d9
leaq 0x587bc(%rip), %rsi # 0xb1383
leaq 0x75df8(%rip), %rcx # 0xce9c6
jmp 0x58c13
leaq 0x58702(%rip), %rdi # 0xb12d9
leaq 0x587a5(%rip), %rsi # 0xb1383
leaq 0x77a6b(%rip), %rcx # 0xd0650
jmp 0x58c13
leaq 0x586eb(%rip), %rdi # 0xb12d9
leaq 0x5878e(%rip), %rsi # 0xb1383
leaq 0x76ccc(%rip), %rcx # 0xcf8c8
jmp 0x58c13
leaq 0x586d4(%rip), %rdi # 0xb12d9
leaq 0x58777(%rip), %rsi # 0xb1383
leaq 0x7767a(%rip), %rcx # 0xd028d
movl $0xb2, %edx
callq 0x143c0
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h
|
Eigen::internal::dense_assignment_loop<Eigen::internal::restricted_packet_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>, Eigen::internal::evaluator<Eigen::Product<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1>>, Eigen::internal::sub_assign_op<double, double>>, 4, 0>::run(Eigen::internal::restricted_packet_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>>, Eigen::internal::evaluator<Eigen::Product<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1>>, Eigen::internal::sub_assign_op<double, double>>&)
|
void run(Kernel &kernel)
{
typedef typename Kernel::Scalar Scalar;
typedef typename Kernel::PacketType PacketType;
enum {
packetSize = unpacket_traits<PacketType>::size,
requestedAlignment = int(Kernel::AssignmentTraits::InnerRequiredAlignment),
alignable = packet_traits<Scalar>::AlignedOnScalar || int(Kernel::AssignmentTraits::DstAlignment)>=sizeof(Scalar),
dstIsAligned = int(Kernel::AssignmentTraits::DstAlignment)>=int(requestedAlignment),
dstAlignment = alignable ? int(requestedAlignment)
: int(Kernel::AssignmentTraits::DstAlignment)
};
const Scalar *dst_ptr = kernel.dstDataPtr();
if((!bool(dstIsAligned)) && (UIntPtr(dst_ptr) % sizeof(Scalar))>0)
{
// the pointer is not aligned-on scalar, so alignment is not possible
return dense_assignment_loop<Kernel,DefaultTraversal,NoUnrolling>::run(kernel);
}
const Index packetAlignedMask = packetSize - 1;
const Index innerSize = kernel.innerSize();
const Index outerSize = kernel.outerSize();
const Index alignedStep = alignable ? (packetSize - kernel.outerStride() % packetSize) & packetAlignedMask : 0;
Index alignedStart = ((!alignable) || bool(dstIsAligned)) ? 0 : internal::first_aligned<requestedAlignment>(dst_ptr, innerSize);
for(Index outer = 0; outer < outerSize; ++outer)
{
const Index alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
// do the non-vectorizable part of the assignment
for(Index inner = 0; inner<alignedStart ; ++inner)
kernel.assignCoeffByOuterInner(outer, inner);
// do the vectorizable part of the assignment
for(Index inner = alignedStart; inner<alignedEnd; inner+=packetSize)
kernel.template assignPacketByOuterInner<dstAlignment, Unaligned, PacketType>(outer, inner);
// do the non-vectorizable part of the assignment
for(Index inner = alignedEnd; inner<innerSize ; ++inner)
kernel.assignCoeffByOuterInner(outer, inner);
alignedStart = numext::mini((alignedStart+alignedStep)%packetSize, innerSize);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq (%rax), %r12
testb $0x7, %r12b
je 0x58cc3
cmpq $0x0, 0x10(%rax)
jle 0x58e56
xorl %r12d, %r12d
xorl %r14d, %r14d
cmpq $0x0, 0x8(%rax)
jle 0x58cb1
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rax), %r13
imulq %r12, %r13
addq (%rax), %r13
movq %r15, %rsi
movq %r14, %rdx
callq 0x58e66
movsd (%r13,%r15,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%r13,%r15,8)
incq %r15
movq 0x18(%rbx), %rax
cmpq 0x8(%rax), %r15
jl 0x58c75
incq %r14
addq $0x8, %r12
cmpq 0x10(%rax), %r14
jl 0x58c6b
jmp 0x58e56
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
testq %rcx, %rcx
jle 0x58e56
movq 0x8(%rax), %rbp
movq 0x18(%rax), %rax
andl $0x1, %eax
movq %rax, 0x8(%rsp)
shrl $0x3, %r12d
andl $0x1, %r12d
cmpq %rbp, %r12
cmovgeq %rbp, %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
testq %r12, %r12
jle 0x58d33
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x10(%rax), %r15
imulq %r14, %r15
xorl %esi, %esi
movq %r14, %rdx
callq 0x58e66
movq (%rsp), %rax
movsd (%rax,%r15,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r15,8)
movq %rbp, %rax
subq %r12, %rax
andq $-0x2, %rax
leaq (%rax,%r12), %r15
testq %rax, %rax
jle 0x58ddd
leaq (,%r12,8), %rax
movq %r12, %rcx
movq 0x8(%rbx), %r8
movq 0x40(%r8), %rdx
testq %rdx, %rdx
jle 0x58da8
movq 0x20(%r8), %rsi
movq 0x38(%r8), %rdi
imulq %r13, %rdi
addq 0x28(%r8), %rdi
movq 0x10(%r8), %r8
addq %rax, %r8
shlq $0x3, %rsi
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
movupd (%r8), %xmm1
movsd (%rdi,%r9,8), %xmm2
unpcklpd %xmm2, %xmm2 # xmm2 = xmm2[0,0]
mulpd %xmm1, %xmm2
addpd %xmm2, %xmm0
incq %r9
addq %rsi, %r8
cmpq %r9, %rdx
jne 0x58d84
jmp 0x58dac
xorpd %xmm0, %xmm0
movq (%rbx), %rdx
movq (%rdx), %rsi
movq 0x10(%rdx), %rdx
imulq %r14, %rdx
leaq (%rsi,%rdx,8), %rdx
movapd (%rdx,%rcx,8), %xmm1
subpd %xmm0, %xmm1
movapd %xmm1, (%rdx,%rcx,8)
addq $0x2, %rcx
addq $0x10, %rax
cmpq %r15, %rcx
jl 0x58d55
movq %r12, (%rsp)
cmpq %rbp, %r15
jge 0x58e23
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
movq %rbp, %r12
movq 0x10(%rax), %rbp
imulq %r13, %rbp
addq (%rax), %rbp
movq %r15, %rsi
movq %r14, %rdx
callq 0x58e66
movsd (%rbp,%r15,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbp,%r15,8)
movq %r12, %rbp
incq %r15
cmpq %r12, %r15
jl 0x58de6
movq (%rsp), %r12
addq 0x8(%rsp), %r12
movq %r12, %rax
shrq $0x3f, %rax
addq %r12, %rax
andq $-0x2, %rax
subq %rax, %r12
cmpq %r12, %rbp
cmovlq %rbp, %r12
incq %r14
addq $0x8, %r13
cmpq 0x10(%rsp), %r14
jne 0x58cfa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h
|
Eigen::internal::product_evaluator<Eigen::Product<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1>, 8, Eigen::DenseShape, Eigen::DenseShape, double, double>::coeff(long, long) const
|
const CoeffReturnType coeff(Index row, Index col) const
{
return (m_lhs.row(row).transpose().cwiseProduct( m_rhs.col(col) )).sum();
}
|
pushq %rbx
movq (%rdi), %r8
movq (%r8), %rax
movq 0x10(%r8), %rcx
testq %rax, %rax
sete %r9b
testq %rcx, %rcx
setns %r10b
orb %r9b, %r10b
je 0x58f33
testq %rsi, %rsi
js 0x58f4a
cmpq %rsi, 0x8(%r8)
jle 0x58f4a
movq 0x8(%rdi), %r9
movq (%r9), %rdi
movq 0x8(%r9), %r10
testq %rdi, %rdi
sete %r11b
testq %r10, %r10
setns %bl
orb %r11b, %bl
je 0x58f61
testq %rdx, %rdx
js 0x58f80
cmpq %rdx, 0x10(%r9)
jle 0x58f80
cmpq %r10, %rcx
jne 0x58f9f
imulq 0x18(%r9), %rdx
testq %rcx, %rcx
je 0x58f2d
jle 0x58fbe
leaq (%rdi,%rdx,8), %rdx
movsd (%rax,%rsi,8), %xmm0
mulsd (%rdx), %xmm0
cmpq $0x1, %rcx
je 0x58f31
movq 0x18(%r8), %rdi
shlq $0x3, %rsi
leaq (%rsi,%rdi,8), %rsi
shlq $0x3, %rdi
addq %rsi, %rax
movl $0x1, %esi
movsd (%rax), %xmm1
mulsd (%rdx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
addq %rdi, %rax
cmpq %rsi, %rcx
jne 0x58f13
jmp 0x58f31
xorpd %xmm0, %xmm0
popq %rbx
retq
leaq 0x5839f(%rip), %rdi # 0xb12d9
leaq 0x58442(%rip), %rsi # 0xb1383
leaq 0x77345(%rip), %rcx # 0xd028d
jmp 0x58f76
leaq 0x581c9(%rip), %rdi # 0xb111a
leaq 0x58269(%rip), %rsi # 0xb11c1
leaq 0x77265(%rip), %rcx # 0xd01c4
jmp 0x58f95
leaq 0x58371(%rip), %rdi # 0xb12d9
leaq 0x58414(%rip), %rsi # 0xb1383
leaq 0x776da(%rip), %rcx # 0xd0650
movl $0xb2, %edx
callq 0x143c0
leaq 0x58193(%rip), %rdi # 0xb111a
leaq 0x58233(%rip), %rsi # 0xb11c1
leaq 0x775e9(%rip), %rcx # 0xd057e
movl $0x7a, %edx
callq 0x143c0
leaq 0x584fb(%rip), %rdi # 0xb14a1
leaq 0x5852d(%rip), %rsi # 0xb14da
leaq 0x773a6(%rip), %rcx # 0xd035a
movl $0x74, %edx
callq 0x143c0
leaq 0x57967(%rip), %rdi # 0xb092c
leaq 0x579a4(%rip), %rsi # 0xb0970
leaq 0x7775e(%rip), %rcx # 0xd0731
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
void Eigen::internal::generic_product_impl<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>>(Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, -1, 1, true>&, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const&, Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, -1, 1, true> const&, double const&)
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rhs.col(0));
return;
}
LhsNested actual_lhs(lhs);
RhsNested actual_rhs(rhs);
internal::gemv_dense_selector<Side,
(int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
>::run(actual_lhs, actual_rhs, dst, alpha);
}
|
subq $0x28, %rsp
movq %rsi, %rax
movq 0x8(%rsi), %r10
movq 0x10(%rsi), %rsi
cmpq $0x1, %r10
jne 0x59083
movq (%rax), %r9
testq %r9, %r9
sete %r8b
testq %rsi, %rsi
setns %r10b
orb %r8b, %r10b
je 0x590d8
movq (%rdx), %r8
movq 0x8(%rdx), %rdx
testq %r8, %r8
sete %r10b
testq %rdx, %rdx
setns %r11b
orb %r10b, %r11b
je 0x590ef
cmpq %rdx, %rsi
jne 0x5910e
movsd (%rcx), %xmm0
testq %rsi, %rsi
je 0x590c0
jle 0x5912d
movsd (%r9), %xmm1
mulsd (%r8), %xmm1
cmpq $0x1, %rsi
je 0x590c4
movq 0x18(%rax), %rax
leaq (%r9,%rax,8), %rcx
shlq $0x3, %rax
movl $0x1, %edx
movsd (%rcx), %xmm2
mulsd (%r8,%rdx,8), %xmm2
addsd %xmm2, %xmm1
incq %rdx
addq %rax, %rcx
cmpq %rdx, %rsi
jne 0x59068
jmp 0x590c4
movq (%rdx), %r8
movsd (%rcx), %xmm0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x18(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x8(%rsp), %rcx
movq %r8, (%rcx)
movq $0x1, 0x8(%rcx)
movq (%rdi), %r8
movl $0x1, %r9d
movq %r10, %rdi
callq 0x3ece6
jmp 0x590d3
xorpd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movq (%rdi), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x28, %rsp
retq
leaq 0x581fa(%rip), %rdi # 0xb12d9
leaq 0x5829d(%rip), %rsi # 0xb1383
leaq 0x771a0(%rip), %rcx # 0xd028d
jmp 0x59104
leaq 0x581e3(%rip), %rdi # 0xb12d9
leaq 0x58286(%rip), %rsi # 0xb1383
leaq 0x77fe9(%rip), %rcx # 0xd10ed
movl $0xb2, %edx
callq 0x143c0
leaq 0x59126(%rip), %rdi # 0xb223b
leaq 0x59136(%rip), %rsi # 0xb2252
leaq 0x77b30(%rip), %rcx # 0xd0c53
movl $0x52, %edx
callq 0x143c0
leaq 0x577f8(%rip), %rdi # 0xb092c
leaq 0x57835(%rip), %rsi # 0xb0970
leaq 0x77ce2(%rip), %rcx # 0xd0e24
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
void Eigen::internal::generic_product_impl<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, 1, -1, false> const, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>>(Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>&, Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, 1, -1, false> const&, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const&, double const&)
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rhs.col(0));
return;
}
LhsNested actual_lhs(lhs);
RhsNested actual_rhs(rhs);
internal::gemv_dense_selector<Side,
(int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
>::run(actual_lhs, actual_rhs, dst, alpha);
}
|
subq $0x88, %rsp
cmpq $0x1, 0x10(%rdx)
jne 0x591fa
movq (%rsi), %r9
movq 0x10(%rsi), %rax
testq %r9, %r9
sete %r8b
testq %rax, %rax
setns %r10b
orb %r8b, %r10b
je 0x59279
movq (%rdx), %r8
movq 0x8(%rdx), %rdx
testq %r8, %r8
sete %r10b
testq %rdx, %rdx
setns %r11b
orb %r10b, %r11b
je 0x59290
cmpq %rdx, %rax
jne 0x592af
movsd (%rcx), %xmm0
testq %rax, %rax
je 0x5925e
jle 0x592ce
movsd (%r9), %xmm1
mulsd (%r8), %xmm1
cmpq $0x1, %rax
je 0x59262
movq 0x18(%rsi), %rcx
movq 0x18(%rcx), %rcx
leaq (%r9,%rcx,8), %rdx
shlq $0x3, %rcx
movl $0x1, %esi
movsd (%rdx), %xmm2
mulsd (%r8,%rsi,8), %xmm2
addsd %xmm2, %xmm1
incq %rsi
addq %rcx, %rdx
cmpq %rsi, %rax
jne 0x591df
jmp 0x59262
movq 0x30(%rsi), %r8
leaq 0x10(%rsp), %rax
movq %r8, 0x30(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movaps %xmm2, 0x20(%rax)
movaps %xmm1, 0x10(%rax)
movaps %xmm0, (%rax)
movq 0x30(%rdi), %rsi
leaq 0x50(%rsp), %r8
movq %rsi, 0x30(%r8)
movupd (%rdi), %xmm0
movupd 0x10(%rdi), %xmm1
movupd 0x20(%rdi), %xmm2
movapd %xmm2, 0x20(%r8)
movapd %xmm1, 0x10(%r8)
movapd %xmm0, (%r8)
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
movq %rax, %rsi
movq %r8, %rdx
callq 0x592ee
jmp 0x59271
xorpd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movq (%rdi), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x88, %rsp
retq
leaq 0x58059(%rip), %rdi # 0xb12d9
leaq 0x580fc(%rip), %rsi # 0xb1383
leaq 0x77f82(%rip), %rcx # 0xd1210
jmp 0x592a5
leaq 0x58042(%rip), %rdi # 0xb12d9
leaq 0x580e5(%rip), %rsi # 0xb1383
leaq 0x773ab(%rip), %rcx # 0xd0650
movl $0xb2, %edx
callq 0x143c0
leaq 0x58f85(%rip), %rdi # 0xb223b
leaq 0x58f95(%rip), %rsi # 0xb2252
leaq 0x7805b(%rip), %rcx # 0xd131f
movl $0x52, %edx
callq 0x143c0
leaq 0x57657(%rip), %rdi # 0xb092c
leaq 0x57694(%rip), %rsi # 0xb0970
leaq 0x7822e(%rip), %rcx # 0xd1511
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
void Eigen::internal::gemv_dense_selector<2, 1, true>::run<Eigen::Transpose<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const>, Eigen::Transpose<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, 1, -1, false> const>, Eigen::Transpose<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>>>(Eigen::Transpose<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const> const&, Eigen::Transpose<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>> const, 1, -1, false> const> const&, Eigen::Transpose<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>>&, Eigen::Transpose<Eigen::Block<Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, 1, -1, false>>::Scalar const&)
|
static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
{
typedef typename Lhs::Scalar LhsScalar;
typedef typename Rhs::Scalar RhsScalar;
typedef typename Dest::Scalar ResScalar;
typedef internal::blas_traits<Lhs> LhsBlasTraits;
typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
typedef internal::blas_traits<Rhs> RhsBlasTraits;
typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);
enum {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1 || ActualRhsTypeCleaned::MaxSizeAtCompileTime==0
};
gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
if(!DirectlyUseRhs)
{
#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
#endif
Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
}
typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
general_matrix_vector_product
<Index,LhsScalar,LhsMapper,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
actualLhs.rows(), actualLhs.cols(),
LhsMapper(actualLhs.data(), actualLhs.outerStride()),
RhsMapper(actualRhsPtr, 1),
dest.data(), dest.col(0).innerStride(), //NOTE if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166)
actualAlpha);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x10(%rsi), %r13
movq %r13, %rax
shrq $0x3d, %rax
jne 0x5935c
movq %rdx, %r14
movq (%rdi), %r12
movq (%rsi), %r15
movq 0x18(%rsi), %rdx
movsd (%rcx), %xmm0
leaq (,%r13,8), %rdi
cmpq $0x4001, %r13 # imm = 0x4001
setae %al
movl %eax, -0x2c(%rbp)
jb 0x5938a
movq %rdx, -0x38(%rbp)
movsd %xmm0, -0x40(%rbp)
callq 0x147f0
movq %rax, %rbx
testb $0xf, %bl
jne 0x59452
testq %rbx, %rbx
movsd -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rdx
jne 0x593a4
movl $0x8, %edi
callq 0x14290
movq 0xb6bcb(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb6c1d(%rip), %rsi # 0x10ff98
movq 0xb6b86(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movq %rsp, %rbx
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rbx
movq %rbx, %rsp
testq %r13, %r13
je 0x5942e
movq 0x18(%rdx), %rax
shlq $0x3, %rax
xorl %ecx, %ecx
movsd (%r15), %xmm1
movsd %xmm1, (%rbx,%rcx,8)
incq %rcx
addq %rax, %r15
cmpq %rcx, %r13
jne 0x593ae
movl -0x2c(%rbp), %r15d
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdi
movq (%r12), %rax
movq 0x18(%r12), %rcx
movq %rax, -0x60(%rbp)
movq %rcx, -0x58(%rbp)
movq %rbx, -0x50(%rbp)
movq $0x1, -0x48(%rbp)
movq (%r14), %r8
testq %r8, %r8
je 0x593fd
cmpq $0x0, 0x10(%r14)
js 0x59433
movq 0x18(%r14), %rax
movq 0x18(%rax), %r9
leaq -0x60(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x3f440
testb %r15b, %r15b
je 0x5941f
movq %rbx, %rdi
callq 0x14720
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
jmp 0x593c7
leaq 0x57e9f(%rip), %rdi # 0xb12d9
leaq 0x57f42(%rip), %rsi # 0xb1383
leaq 0x78392(%rip), %rcx # 0xd17da
movl $0xb2, %edx
callq 0x143c0
leaq 0x579b2(%rip), %rdi # 0xb0e0b
leaq 0x57a66(%rip), %rsi # 0xb0ec6
leaq 0x57acc(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
movq %rax, %r14
testb %r15b, %r15b
je 0x59481
movq %rbx, %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/GeneralProduct.h
|
Eigen::internal::gemm_functor<double, long, Eigen::internal::general_matrix_matrix_product<long, double, 0, false, double, 0, false, 0, 1>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::Ref<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0, Eigen::OuterStride<-1>>, Eigen::internal::gemm_blocking_space<0, double, double, -1, -1, -1, 1, false>>::operator()(long, long, long, long, Eigen::internal::GemmParallelInfo<long>*) const
|
void operator() (Index row, Index rows, Index col=0, Index cols=-1, GemmParallelInfo<Index>* info=0) const
{
if(cols==-1)
cols = m_rhs.cols();
Gemm::run(rows, cols, m_lhs.cols(),
&m_lhs.coeffRef(row,0), m_lhs.outerStride(),
&m_rhs.coeffRef(0,col), m_rhs.outerStride(),
(Scalar*)&(m_dest.coeffRef(row,col)), m_dest.innerStride(), m_dest.outerStride(),
m_actualAlpha, m_blocking, info);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rax
movq %r8, %r14
movq %rdx, %r11
movq %rdi, %r10
movq 0x8(%rdi), %rdi
cmpq $-0x1, %r8
jne 0x594ad
movq 0x10(%rdi), %r14
leaq (,%rsi,8), %rbx
movq (%r10), %r8
addq (%r8), %rbx
movq 0x10(%r10), %r12
movq 0x10(%r8), %rdx
movq 0x18(%rdi), %r15
movq %r15, %r9
imulq %rcx, %r9
shlq $0x3, %r9
addq (%rdi), %r9
movq 0x18(%r8), %r8
movq 0x18(%r12), %r13
imulq %r13, %rcx
shlq $0x3, %rcx
addq (%r12), %rcx
leaq (%rcx,%rsi,8), %r12
movsd 0x18(%r10), %xmm0
movq %r11, %rdi
movq %r14, %rsi
movq %rbx, %rcx
pushq %rax
pushq 0x20(%r10)
pushq %r13
pushq $0x1
pushq %r12
pushq %r15
callq 0x4053e
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/products/GeneralMatrixMatrix.h
|
Eigen::PermutationMatrix<-1, -1, int>& Eigen::PermutationBase<Eigen::PermutationMatrix<-1, -1, int>>::operator=<Eigen::Transpositions<-1, -1, int>>(Eigen::TranspositionsBase<Eigen::Transpositions<-1, -1, int>> const&)
|
Derived& operator=(const TranspositionsBase<OtherDerived>& tr)
{
setIdentity(tr.size());
for(Index k=size()-1; k>=0; --k)
applyTranspositionOnTheRight(k,tr.coeff(k));
return derived();
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
callq 0x5956a
movq 0x8(%rbx), %r15
testq %r15, %r15
jle 0x59560
decq %r15
movq (%r14), %rax
movslq (%rax,%r15,4), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x59648
leaq -0x1(%r15), %rax
incq %r15
cmpq $0x1, %r15
movq %rax, %r15
ja 0x5953e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/PermutationMatrix.h
|
void Eigen::PartialPivLU<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::_solve_impl<Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, 3, 3, 0, 3, 3>>(Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3>&) const
|
inline const PermutationType& permutationP() const
{
eigen_assert(m_isInitialized && "PartialPivLU is not initialized.");
return m_p;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x0, 0x41(%rdi)
je 0x598d8
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x20(%rdi)
jne 0x598f7
cmpq $0x3, %rax
jne 0x59916
cmpq $0x3, 0x8(%rsi)
jne 0x59916
movq %rdx, %rbx
movq 0x18(%r14), %rax
xorl %ecx, %ecx
movsd 0x557c3(%rip), %xmm0 # 0xaf008
movl (%rax,%rcx), %edx
cmpq $0x3, %rdx
jae 0x598b9
movaps %xmm0, %xmm1
testq %rcx, %rcx
je 0x59859
xorps %xmm1, %xmm1
movsd %xmm1, (%rbx,%rdx,8)
movaps %xmm0, %xmm1
cmpq $0x4, %rcx
je 0x5986a
xorps %xmm1, %xmm1
movsd %xmm1, 0x18(%rbx,%rdx,8)
movaps %xmm0, %xmm1
cmpq $0x8, %rcx
je 0x5987c
xorps %xmm1, %xmm1
movsd %xmm1, 0x30(%rbx,%rdx,8)
addq $0x4, %rcx
cmpq $0xc, %rcx
jne 0x59845
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x59936
movq %r14, (%r15)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x59a3e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5785a(%rip), %rdi # 0xb111a
leaq 0x578fa(%rip), %rsi # 0xb11c1
leaq 0x78688(%rip), %rcx # 0xd1f56
movl $0x7a, %edx
callq 0x143c0
leaq 0x7814c(%rip), %rdi # 0xd1a2b
leaq 0x7443d(%rip), %rsi # 0xcdd23
leaq 0x785dc(%rip), %rcx # 0xd1ec9
movl $0x99, %edx
callq 0x143c0
leaq 0x5820f(%rip), %rdi # 0xb1b0d
leaq 0x58294(%rip), %rsi # 0xb1b99
leaq 0x78463(%rip), %rcx # 0xd1d6f
movl $0x62, %edx
callq 0x143c0
leaq 0x57273(%rip), %rdi # 0xb0b90
leaq 0x573fb(%rip), %rsi # 0xb0d1f
leaq 0x742ef(%rip), %rcx # 0xcdc1a
movl $0x115, %edx # imm = 0x115
callq 0x143c0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/LU/PartialPivLU.h
|
Eigen::internal::triangular_solver_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, 3, 3, 0, 3, 3>, 1, 5, 0, -1>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3>&)
|
static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
{
typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
const Index size = lhs.rows();
const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;
BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);
triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor, Rhs::InnerStrideAtCompileTime>
::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.innerStride(), rhs.outerStride(), blocking);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movl $0x3, %r13d
movq %r13, (%rsi)
movq %r13, 0x8(%rsi)
leaq 0x20(%rsp), %r12
movq %r14, (%r12)
leaq 0x38(%rsp), %rdx
movq %r13, (%rdx)
movl $0x1, %ecx
movq %r12, %rdi
callq 0x58362
movq (%r12), %rax
movq -0x10(%r12), %rcx
imulq %rax, %rcx
movq %rcx, 0x8(%r12)
imulq -0x8(%r12), %rax
movq %rax, 0x10(%r12)
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rsp, %rax
movl $0x3, %esi
movl $0x1, %r9d
movq %r14, %rdi
movq %rbx, %r8
pushq %rax
pushq %r13
callq 0x57a4a
addq $0x10, %rsp
movq (%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rdi
callq 0x14720
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/SolveTriangular.h
|
Eigen::internal::triangular_solver_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, Eigen::Matrix<double, 3, 3, 0, 3, 3>, 1, 2, 0, -1>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3>&)
|
static EIGEN_DEVICE_FUNC void run(const Lhs& lhs, Rhs& rhs)
{
typename internal::add_const_on_value_type<ActualLhsType>::type actualLhs = LhsProductTraits::extract(lhs);
const Index size = lhs.rows();
const Index othersize = Side==OnTheLeft? rhs.cols() : rhs.rows();
typedef internal::gemm_blocking_space<(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor,Scalar,Scalar,
Rhs::MaxRowsAtCompileTime, Rhs::MaxColsAtCompileTime, Lhs::MaxRowsAtCompileTime,4> BlockingType;
BlockingType blocking(rhs.rows(), rhs.cols(), size, 1, false);
triangular_solve_matrix<Scalar,Index,Side,Mode,LhsProductTraits::NeedToConjugate,(int(Lhs::Flags) & RowMajorBit) ? RowMajor : ColMajor,
(Rhs::Flags&RowMajorBit) ? RowMajor : ColMajor, Rhs::InnerStrideAtCompileTime>
::run(size, othersize, &actualLhs.coeffRef(0,0), actualLhs.outerStride(), &rhs.coeffRef(0,0), rhs.innerStride(), rhs.outerStride(), blocking);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, -0x10(%rsi)
movl $0x3, %r13d
movq %r13, (%rsi)
movq %r13, 0x8(%rsi)
leaq 0x20(%rsp), %r12
movq %r14, (%r12)
leaq 0x38(%rsp), %rdx
movq %r13, (%rdx)
movl $0x1, %ecx
movq %r12, %rdi
callq 0x58362
movq (%r12), %rax
movq -0x10(%r12), %rcx
imulq %rax, %rcx
movq %rcx, 0x8(%r12)
imulq -0x8(%r12), %rax
movq %rax, 0x10(%r12)
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rsp, %rax
movl $0x3, %esi
movl $0x1, %r9d
movq %r14, %rdi
movq %rbx, %r8
pushq %rax
pushq %r13
callq 0x59b46
addq $0x10, %rsp
movq (%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rdi
callq 0x14720
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x14720
movq 0x8(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/SolveTriangular.h
|
Eigen::internal::triangular_solve_matrix<double, long, 1, 2, false, 0, 0, 1>::run(long, long, double const*, long, double*, long, long, Eigen::internal::level3_blocking<double, double>&)
|
EIGEN_DONT_INLINE void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor,OtherInnerStride>::run(
Index size, Index otherSize,
const Scalar* _tri, Index triStride,
Scalar* _other, Index otherIncr, Index otherStride,
level3_blocking<Scalar,Scalar>& blocking)
{
Index cols = otherSize;
typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
typedef blas_data_mapper<Scalar, Index, ColMajor, Unaligned, OtherInnerStride> OtherMapper;
TriMapper tri(_tri, triStride);
OtherMapper other(_other, otherStride, otherIncr);
typedef gebp_traits<Scalar,Scalar> Traits;
enum {
SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
IsLower = (Mode&Lower) == Lower
};
Index kc = blocking.kc(); // cache block size along the K direction
Index mc = (std::min)(size,blocking.mc()); // cache block size along the M direction
std::size_t sizeA = kc*mc;
std::size_t sizeB = kc*cols;
ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
conj_if<Conjugate> conj;
gebp_kernel<Scalar, Scalar, Index, OtherMapper, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel;
gemm_pack_lhs<Scalar, Index, TriMapper, Traits::mr, Traits::LhsProgress, typename Traits::LhsPacket4Packing, TriStorageOrder> pack_lhs;
gemm_pack_rhs<Scalar, Index, OtherMapper, Traits::nr, ColMajor, false, true> pack_rhs;
// the goal here is to subdivise the Rhs panels such that we keep some cache
// coherence when accessing the rhs elements
std::ptrdiff_t l1, l2, l3;
manage_caching_sizes(GetAction, &l1, &l2, &l3);
Index subcols = cols>0 ? l2/(4 * sizeof(Scalar) * std::max<Index>(otherStride,size)) : 0;
subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr);
for(Index k2=IsLower ? 0 : size;
IsLower ? k2<size : k2>0;
IsLower ? k2+=kc : k2-=kc)
{
const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc);
// We have selected and packed a big horizontal panel R1 of rhs. Let B be the packed copy of this panel,
// and R2 the remaining part of rhs. The corresponding vertical panel of lhs is split into
// A11 (the triangular part) and A21 the remaining rectangular part.
// Then the high level algorithm is:
// - B = R1 => general block copy (done during the next step)
// - R1 = A11^-1 B => tricky part
// - update B from the new R1 => actually this has to be performed continuously during the above step
// - R2 -= A21 * B => GEPP
// The tricky part: compute R1 = A11^-1 B while updating B from R1
// The idea is to split A11 into multiple small vertical panels.
// Each panel can be split into a small triangular part T1k which is processed without optimization,
// and the remaining small part T2k which is processed using gebp with appropriate block strides
for(Index j2=0; j2<cols; j2+=subcols)
{
Index actual_cols = (std::min)(cols-j2,subcols);
// for each small vertical panels [T1k^T, T2k^T]^T of lhs
for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth)
{
Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth);
// tr solve
for (Index k=0; k<actualPanelWidth; ++k)
{
// TODO write a small kernel handling this (can be shared with trsv)
Index i = IsLower ? k2+k1+k : k2-k1-k-1;
Index rs = actualPanelWidth - k - 1; // remaining size
Index s = TriStorageOrder==RowMajor ? (IsLower ? k2+k1 : i+1)
: IsLower ? i+1 : i-rs;
Scalar a = (Mode & UnitDiag) ? Scalar(1) : Scalar(1)/conj(tri(i,i));
for (Index j=j2; j<j2+actual_cols; ++j)
{
if (TriStorageOrder==RowMajor)
{
Scalar b(0);
const Scalar* l = &tri(i,s);
typename OtherMapper::LinearMapper r = other.getLinearMapper(s,j);
for (Index i3=0; i3<k; ++i3)
b += conj(l[i3]) * r(i3);
other(i,j) = (other(i,j) - b)*a;
}
else
{
Scalar& otherij = other(i,j);
otherij *= a;
Scalar b = otherij;
typename OtherMapper::LinearMapper r = other.getLinearMapper(s,j);
typename TriMapper::LinearMapper l = tri.getLinearMapper(s,i);
for (Index i3=0;i3<rs;++i3)
r(i3) -= b * conj(l(i3));
}
}
}
Index lengthTarget = actual_kc-k1-actualPanelWidth;
Index startBlock = IsLower ? k2+k1 : k2-k1-actualPanelWidth;
Index blockBOffset = IsLower ? k1 : lengthTarget;
// update the respective rows of B from other
pack_rhs(blockB+actual_kc*j2, other.getSubMapper(startBlock,j2), actualPanelWidth, actual_cols, actual_kc, blockBOffset);
// GEBP
if (lengthTarget>0)
{
Index startTarget = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc;
pack_lhs(blockA, tri.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
gebp_kernel(other.getSubMapper(startTarget,j2), blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1),
actualPanelWidth, actual_kc, 0, blockBOffset);
}
}
}
// R2 -= A21 * B => GEPP
{
Index start = IsLower ? k2+kc : 0;
Index end = IsLower ? size : k2-kc;
for(Index i2=start; i2<end; i2+=mc)
{
const Index actual_mc = (std::min)(mc,end-i2);
if (actual_mc>0)
{
pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2-kc), actual_kc, actual_mc);
gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0);
}
}
}
}
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movq %rdx, -0xd0(%rbp)
cmpq $0x1, %r9
jne 0x5a361
movq %rcx, %r13
movq 0x18(%rbp), %rbx
movq 0x10(%rbx), %r15
movq 0x20(%rbx), %rcx
cmpq %rdi, %r15
movq %rdi, -0x38(%rbp)
cmovgeq %rdi, %r15
movq %r15, -0xb0(%rbp)
imulq %rcx, %r15
movq %r15, %rax
shrq $0x3d, %rax
jne 0x5a380
movq %r8, %r14
movq (%rbx), %rax
movq %rax, -0x60(%rbp)
testq %rax, %rax
movq %rsi, -0x58(%rbp)
movq %rcx, -0x90(%rbp)
je 0x59bbc
xorl %r12d, %r12d
jmp 0x59c03
leaq (,%r15,8), %rdi
cmpq $0x4000, %r15 # imm = 0x4000
ja 0x59be4
movq %rsp, %r12
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %r12
movq %r12, %rsp
movq %r12, -0x60(%rbp)
jmp 0x59c03
callq 0x147f0
movq %rax, %r12
testb $0xf, %r12b
jne 0x5a411
movq %r12, -0x60(%rbp)
testq %r12, %r12
je 0x5a413
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
movq -0x90(%rbp), %rcx
imulq -0x58(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
cmpq %rax, %rcx
ja 0x5a3ae
movq 0x8(%rbx), %rax
movq %rax, -0x98(%rbp)
testq %rax, %rax
je 0x59c3d
xorl %eax, %eax
jmp 0x59c8b
movq -0xa8(%rbp), %rax
leaq (,%rax,8), %rdi
cmpq $0x4000, %rax # imm = 0x4000
ja 0x59c6e
movq %rsp, %rax
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rax
movq %rax, %rsp
movq %rax, -0x98(%rbp)
jmp 0x59c8b
callq 0x147f0
testb $0xf, %al
jne 0x5a418
movq %rax, -0x98(%rbp)
testq %rax, %rax
je 0x5a437
movq %rax, -0xe0(%rbp)
leaq 0xb6f0f(%rip), %rax # 0x110ba8
movb (%rax), %al
testb %al, %al
movq %r13, -0x68(%rbp)
movq %r15, -0xf0(%rbp)
movq %r12, -0xe8(%rbp)
je 0x5a3dc
movq 0x10(%rbp), %rbx
cmpq $0x0, -0x58(%rbp)
jle 0x59cf3
leaq 0xb6ec9(%rip), %rax # 0x110b90
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rsi
cmpq %rsi, %rbx
movq %rsi, %rcx
cmovgq %rbx, %rcx
shlq $0x5, %rcx
xorl %edx, %edx
divq %rcx
leaq 0x3(%rax), %rdi
testq %rax, %rax
cmovnsq %rax, %rdi
andq $-0x4, %rdi
jmp 0x59cf9
xorl %edi, %edi
movq -0x38(%rbp), %rsi
cmpq $0x5, %rdi
movl $0x4, %eax
cmovlq %rax, %rdi
testq %rsi, %rsi
movq -0x58(%rbp), %rdx
movq -0x90(%rbp), %rsi
jle 0x5a320
movq -0x38(%rbp), %rax
decq %rax
imulq %r13, %rax
movq -0x38(%rbp), %rcx
leaq (,%rcx,8), %rcx
leaq (%rcx,%rax,8), %rax
movq -0xd0(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x110(%rbp)
leaq (,%r13,8), %rax
movq %rax, %r8
xorq $-0x8, %r8
imulq %rsi, %r8
movq %r8, -0x140(%rbp)
movq %r13, %r8
notq %r8
shlq $0x5, %r8
movq %r8, -0x170(%rbp)
negq %rax
movq %rax, -0x188(%rbp)
movq -0x38(%rbp), %rax
leaq (%r14,%rax,8), %rax
movq %rax, -0xf8(%rbp)
leaq (,%rsi,8), %rax
negq %rax
movq %rax, -0x138(%rbp)
movq %rbx, %rax
imulq %rdi, %rax
shlq $0x3, %rax
movq %rax, -0x150(%rbp)
leaq (,%rbx,8), %r15
movq -0x38(%rbp), %r8
subq %rsi, %r8
movq -0xb0(%rbp), %rax
leaq (,%rax,8), %rax
movq %rax, -0x158(%rbp)
movq %r13, %rax
movq %r8, -0x108(%rbp)
imulq %r8, %rax
leaq (%rcx,%rax,8), %rax
movq %rax, -0x100(%rbp)
movq -0x38(%rbp), %rax
movq %rsi, %rcx
imulq %r13, %rcx
shlq $0x3, %rcx
negq %rcx
movq %rcx, -0x130(%rbp)
movsd 0x551fb(%rip), %xmm3 # 0xaf008
movapd 0x5627b(%rip), %xmm4 # 0xb0090
movq %rdi, -0x118(%rbp)
cmpq %rax, %rsi
movq %rax, -0x38(%rbp)
movq %rax, %r9
cmovlq %rsi, %r9
testq %rdx, %rdx
movq %r9, -0x70(%rbp)
jle 0x5a19c
movq -0x38(%rbp), %rcx
subq %r9, %rcx
movq -0xd0(%rbp), %rax
movq %rcx, -0x148(%rbp)
leaq (%rax,%rcx,8), %rax
movq %rax, -0x160(%rbp)
movq -0xf8(%rbp), %rax
movq %rax, -0xb8(%rbp)
xorl %ecx, %ecx
movq %rcx, -0xd8(%rbp)
subq %rcx, %rdx
cmpq %rdx, %rdi
movq %rdx, -0xa0(%rbp)
cmovlq %rdi, %rdx
movq %rdx, -0xc0(%rbp)
testq %r9, %r9
jle 0x5a169
movq -0xd8(%rbp), %rdx
movq -0xc0(%rbp), %rax
leaq (%rax,%rdx), %r12
movq %rdx, %rax
imulq %r9, %rax
movq -0x98(%rbp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, -0x128(%rbp)
movq %rdx, %rax
imulq %rbx, %rax
leaq (%r14,%rax,8), %rcx
movq -0x148(%rbp), %rax
movq %rcx, -0x178(%rbp)
leaq (%rcx,%rax,8), %rax
movq %rax, -0x168(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x110(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq %r9, %rcx
xorl %edx, %edx
movl $0x4, %eax
cmpq %rax, %rcx
movl $0x4, %esi
movq %rcx, -0x180(%rbp)
cmovlq %rcx, %rsi
cmpq $0x2, %rsi
movl $0x1, %eax
cmovgeq %rsi, %rax
movq %rdx, -0x88(%rbp)
subq %rdx, %r9
cmpq $0x4, %r9
movl $0x4, %ecx
cmovlq %r9, %rcx
movq %rcx, -0x80(%rbp)
movq %r9, -0x78(%rbp)
testq %r9, %r9
jle 0x5a018
shlq $0x3, %rsi
movq -0xc8(%rbp), %rcx
subq %rsi, %rcx
movq -0x120(%rbp), %rdx
subq %rsi, %rdx
xorl %esi, %esi
cmpq $0x0, -0xa0(%rbp)
jle 0x5a005
movq -0x88(%rbp), %rdi
addq %rsi, %rdi
notq %rdi
addq -0x38(%rbp), %rdi
movq %rsi, %r8
notq %r8
addq -0x80(%rbp), %r8
movq %rdi, %r9
imulq %r13, %r9
movq -0xd0(%rbp), %r10
leaq (%r10,%r9,8), %r9
movapd %xmm3, %xmm0
divsd (%r9,%rdi,8), %xmm0
movq %rdx, %r9
movq -0xd8(%rbp), %r10
movq %r10, %r11
imulq %rbx, %r11
leaq (%r14,%r11,8), %r11
movsd (%r11,%rdi,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r11,%rdi,8)
testq %r8, %r8
jle 0x59ffa
xorpd %xmm4, %xmm1
xorl %r11d, %r11d
movsd (%rcx,%r11,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r9,%r11,8), %xmm2
movsd %xmm2, (%r9,%r11,8)
incq %r11
cmpq %r8, %r11
jl 0x59fdc
incq %r10
addq %r15, %r9
cmpq %r12, %r10
jl 0x59fb5
incq %rsi
addq -0x188(%rbp), %rcx
cmpq %rax, %rsi
jne 0x59f66
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %r13
subq %rcx, %r13
movq -0x88(%rbp), %rax
addq %rcx, %rax
movq -0x38(%rbp), %rdx
subq %rax, %rdx
movq -0x178(%rbp), %rax
movq %rdx, -0x78(%rbp)
leaq (%rax,%rdx,8), %rax
movq %rax, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
subq $0x8, %rsp
leaq -0x49(%rbp), %rdi
movq -0x128(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq -0xc0(%rbp), %r8
movq -0x70(%rbp), %r9
pushq %r13
callq 0x586d0
addq $0x10, %rsp
testq %r13, %r13
jle 0x5a115
movq %r13, %r8
movq -0x68(%rbp), %rcx
movq -0x78(%rbp), %rdx
imulq %rcx, %rdx
movq -0x160(%rbp), %rax
leaq (%rax,%rdx,8), %rax
movq %rax, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq -0x80(%rbp), %r13
movq %r13, %rcx
xorl %r9d, %r9d
pushq $0x0
movq %r8, -0x78(%rbp)
callq 0x40aca
addq $0x10, %rsp
movq -0x168(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
subq $0x8, %rsp
leaq -0x2a(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x128(%rbp), %rcx
movq -0x78(%rbp), %r8
movq %r13, %r9
movsd 0x55f83(%rip), %xmm0 # 0xb0080
pushq %r8
pushq $0x0
pushq -0x70(%rbp)
pushq %r13
pushq -0xc0(%rbp)
callq 0x40d48
addq $0x30, %rsp
movq -0x88(%rbp), %rdx
addq $0x4, %rdx
movq -0x180(%rbp), %rcx
addq $-0x4, %rcx
movq -0xc8(%rbp), %rax
addq -0x170(%rbp), %rax
movq %rax, -0xc8(%rbp)
addq $-0x20, -0x120(%rbp)
movq -0x70(%rbp), %r9
cmpq %r9, %rdx
movq -0x68(%rbp), %r13
movsd 0x54ead(%rip), %xmm3 # 0xaf008
movapd 0x55f2d(%rip), %xmm4 # 0xb0090
jl 0x59eff
movq -0x118(%rbp), %rdi
movq -0xd8(%rbp), %rcx
addq %rdi, %rcx
movq -0xb8(%rbp), %rax
addq -0x150(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x58(%rbp), %rdx
cmpq %rdx, %rcx
jl 0x59e67
movq -0x38(%rbp), %rax
subq -0x90(%rbp), %rax
jle 0x5a320
movq -0x100(%rbp), %rdi
movq %r14, %r8
movq -0x108(%rbp), %r10
xorl %r13d, %r13d
movq -0xb0(%rbp), %rcx
leaq -0x48(%rbp), %rdx
movq %rax, -0x38(%rbp)
movq %r10, %r12
subq %rcx, %r10
cmovgeq %rcx, %r12
testq %r12, %r12
jle 0x5a2b7
movq %r10, -0x80(%rbp)
movq %r8, -0xa0(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, -0x48(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
subq $0x8, %rsp
leaq -0x29(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq %r9, %rcx
movq %r12, %r8
xorl %r9d, %r9d
pushq $0x0
callq 0x40aca
addq $0x10, %rsp
movq -0xa0(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
subq $0x30, %rsp
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rsp)
movq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq -0x58(%rbp), %rax
movq %rax, (%rsp)
leaq -0x2a(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x98(%rbp), %rcx
movq %r12, %r8
movq -0x70(%rbp), %r9
movsd 0x55e07(%rip), %xmm0 # 0xb0080
callq 0x40d48
addq $0x30, %rsp
movq -0x38(%rbp), %rax
movq -0xb0(%rbp), %rcx
movsd 0x54d73(%rip), %xmm3 # 0xaf008
movapd 0x55df3(%rip), %xmm4 # 0xb0090
leaq -0x48(%rbp), %rdx
movq -0x70(%rbp), %r9
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %r8
movq -0x80(%rbp), %r10
addq %rcx, %r13
movq -0x158(%rbp), %rsi
addq %rsi, %r8
addq %rsi, %rdi
cmpq %rax, %r13
jl 0x5a1d0
movq -0x140(%rbp), %rcx
addq %rcx, -0x110(%rbp)
movq -0x138(%rbp), %rcx
addq %rcx, -0xf8(%rbp)
movq -0x90(%rbp), %rsi
subq %rsi, -0x108(%rbp)
movq -0x130(%rbp), %rcx
addq %rcx, -0x100(%rbp)
testq %rax, %rax
movq -0x68(%rbp), %r13
movq -0x58(%rbp), %rdx
movq -0x118(%rbp), %rdi
jg 0x59e1c
cmpq $0x4001, -0xa8(%rbp) # imm = 0x4001
jb 0x5a339
movq -0xe0(%rbp), %rdi
callq 0x14720
cmpq $0x4001, -0xf0(%rbp) # imm = 0x4001
movq -0xe8(%rbp), %rdi
jb 0x5a352
callq 0x14720
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x584a0(%rip), %rdi # 0xb2808
leaq 0x584a1(%rip), %rsi # 0xb2810
leaq 0x58cfa(%rip), %rcx # 0xb3070
movl $0xae, %edx
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xb5ba7(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb5bf9(%rip), %rsi # 0x10ff98
movq 0xb5b62(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movl $0x8, %edi
callq 0x14290
movq 0xb5b79(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb5bcb(%rip), %rsi # 0x10ff98
movq 0xb5b34(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0xb67c5(%rip), %rdi # 0x110ba8
callq 0x14af0
testl %eax, %eax
je 0x59cb5
leaq 0xb6799(%rip), %rdi # 0x110b90
callq 0x40068
leaq 0xb67a5(%rip), %rdi # 0x110ba8
callq 0x143a0
movq -0x68(%rbp), %r13
jmp 0x59cb5
jmp 0x5a418
jmp 0x5a380
leaq 0x569ec(%rip), %rdi # 0xb0e0b
leaq 0x56aa0(%rip), %rsi # 0xb0ec6
leaq 0x56b06(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xb5af0(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb5b42(%rip), %rsi # 0x10ff98
movq 0xb5aab(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movq %rax, %rbx
leaq 0xb6739(%rip), %rdi # 0x110ba8
callq 0x14390
jmp 0x5a488
jmp 0x5a478
movq %rax, %rbx
jmp 0x5a4af
jmp 0x5a485
jmp 0x5a485
jmp 0x5a485
jmp 0x5a485
movq %rax, %rbx
cmpq $0x4001, -0xa8(%rbp) # imm = 0x4001
movq -0xf0(%rbp), %r15
movq -0xe8(%rbp), %r12
jb 0x5a4af
movq -0xe0(%rbp), %rdi
callq 0x14720
cmpq $0x4001, %r15 # imm = 0x4001
jb 0x5a4c0
movq %r12, %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/products/TriangularSolverMatrix.h
|
double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const>>, 3, 0>::run<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const>>(Eigen::internal::redux_evaluator<Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const>> const&, Eigen::internal::scalar_sum_op<double, double> const&, Eigen::CwiseUnaryOp<Eigen::internal::scalar_abs2_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const&)
|
EIGEN_CONSTEXPR
Index rows() const EIGEN_NOEXCEPT { return m_xpr.rows(); }
|
movq (%rdx), %rax
movq 0x8(%rax), %rax
leaq 0x3(%rax), %rsi
testq %rax, %rax
cmovnsq %rax, %rsi
leaq 0x1(%rax), %rdx
movq 0x8(%rdi), %rcx
cmpq $0x3, %rdx
jae 0x5a60b
movsd (%rcx), %xmm0
mulsd %xmm0, %xmm0
retq
movq %rax, %rdx
shrq $0x3f, %rdx
addq %rax, %rdx
andq $-0x2, %rdx
movapd (%rcx), %xmm1
mulpd %xmm1, %xmm1
cmpq $0x4, %rax
jl 0x5a681
andq $-0x4, %rsi
movapd 0x10(%rcx), %xmm0
mulpd %xmm0, %xmm0
cmpq $0x8, %rax
jb 0x5a663
movl $0x4, %edi
movapd (%rcx,%rdi,8), %xmm2
movapd 0x10(%rcx,%rdi,8), %xmm3
mulpd %xmm2, %xmm2
addpd %xmm2, %xmm1
mulpd %xmm3, %xmm3
addpd %xmm3, %xmm0
addq $0x4, %rdi
cmpq %rsi, %rdi
jl 0x5a63f
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
addpd %xmm2, %xmm1
cmpq %rsi, %rdx
jle 0x5a681
movapd (%rcx,%rsi,8), %xmm0
mulpd %xmm0, %xmm0
addpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cmpq %rax, %rdx
jge 0x5a6a7
movsd (%rcx,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x5a692
retq
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/CwiseUnaryOp.h
|
void Eigen::internal::call_assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false> const, Eigen::Product<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>, 0> const>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false> const, Eigen::Product<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>, 0> const> const&, Eigen::internal::assign_op<double, double> const&, Eigen::internal::enable_if<evaluator_assume_aliasing<Eigen::CwiseBinaryOp<Eigen::internal::scalar_sum_op<double, double>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false> const, Eigen::Product<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>, 0> const>>::value, void*>::type)
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
typename plain_matrix_type<Src>::type tmp(src);
call_assignment_no_alias(dst, tmp, func);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
leaq 0xf(%rsp), %rdx
callq 0x5a93c
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rbx
cmpq %rbx, 0x8(%r14)
je 0x5a890
testq %rbx, %rbx
js 0x5a8e7
movl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x4476c
cmpq %rbx, 0x8(%r14)
jne 0x5a906
movq (%r14), %rax
movq %rbx, %rcx
shrq $0x3f, %rcx
addq %rbx, %rcx
andq $-0x2, %rcx
cmpq $0x2, %rbx
jl 0x5a8bb
xorl %edx, %edx
movaps (%r15,%rdx,8), %xmm0
movaps %xmm0, (%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x5a8a9
cmpq %rbx, %rcx
jge 0x5a8d3
movsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rbx
jne 0x5a8c0
movq 0x10(%rsp), %rdi
callq 0x14720
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x562a2(%rip), %rdi # 0xb0b90
leaq 0x5642a(%rip), %rsi # 0xb0d1f
leaq 0x5bac8(%rip), %rcx # 0xb63c4
movl $0x115, %edx # imm = 0x115
callq 0x143c0
leaq 0x56659(%rip), %rdi # 0xb0f66
leaq 0x56681(%rip), %rsi # 0xb0f95
leaq 0x789a5(%rip), %rcx # 0xd32c0
movl $0x2fd, %edx # imm = 0x2FD
callq 0x143c0
jmp 0x5a927
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h
|
Eigen::internal::dense_assignment_loop<Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::evaluator<Eigen::Product<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>, 1>>, Eigen::internal::add_assign_op<double, double>, 0>, 3, 0>::run(Eigen::internal::generic_dense_assignment_kernel<Eigen::internal::evaluator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::internal::evaluator<Eigen::Product<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>, 1>>, Eigen::internal::add_assign_op<double, double>, 0>&)
|
Index size() const EIGEN_NOEXCEPT { return m_dstExpr.size(); }
|
pushq %rbx
movq 0x18(%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
cmpq $0x2, %rax
jl 0x5ab3d
xorl %edx, %edx
movq (%rdi), %rsi
movq 0x8(%rdi), %r8
movq (%rsi), %rsi
movq 0x40(%r8), %r9
movq 0x48(%r8), %r8
movupd (%r9,%rdx,8), %xmm0
movsd (%r8), %xmm1
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
mulpd %xmm0, %xmm1
addpd (%rsi,%rdx,8), %xmm1
movapd %xmm1, (%rsi,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x5ab05
cmpq %rax, %rcx
jge 0x5ab9d
cmpq $-0x1, %rax
jl 0x5ab9f
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq (%rsi), %rsi
movq (%rdx), %r8
movq (%r8), %rdi
movq 0x8(%r8), %r8
cmpq %rcx, %r8
jle 0x5ab9f
movq 0x8(%rdx), %r9
movq 0x10(%rdx), %r10
testq %r9, %r9
sete %r11b
testq %r10, %r10
setns %bl
orb %r11b, %bl
je 0x5abdd
cmpq $0x1, %r10
jne 0x5abbe
movsd (%rdi,%rcx,8), %xmm0
mulsd (%r9), %xmm0
addsd (%rsi,%rcx,8), %xmm0
movsd %xmm0, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5ab5c
popq %rbx
retq
leaq 0x56574(%rip), %rdi # 0xb111a
leaq 0x56614(%rip), %rsi # 0xb11c1
leaq 0x7825a(%rip), %rcx # 0xd2e0e
movl $0x7a, %edx
callq 0x143c0
leaq 0x568dc(%rip), %rdi # 0xb14a1
leaq 0x5690e(%rip), %rsi # 0xb14da
leaq 0x782ec(%rip), %rcx # 0xd2ebf
movl $0x74, %edx
callq 0x143c0
leaq 0x566f5(%rip), %rdi # 0xb12d9
leaq 0x56798(%rip), %rsi # 0xb1383
leaq 0x784ed(%rip), %rcx # 0xd30df
movl $0xb2, %edx
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h
|
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::IndexedView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::internal::AllRange<-1>>>(Eigen::DenseBase<Eigen::IndexedView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, -1, 1, 0, -1, 1>, Eigen::internal::AllRange<-1>>> const&)
|
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
: m_storage()
{
_check_template_params();
resizeLike(other);
_set_noalias(other);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%rsi), %r8
movq 0x18(%rsi), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x5ac40
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x5ac91
movq %rcx, %rax
orq %r8, %rax
js 0x5ac72
movq %rcx, %rsi
imulq %r8, %rsi
movq %rbx, %rdi
movq %r8, %rdx
callq 0x3e05a
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5acd2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x55f17(%rip), %rdi # 0xb0b90
leaq 0x5609f(%rip), %rsi # 0xb0d1f
leaq 0x56109(%rip), %rcx # 0xb0d90
movl $0x115, %edx # imm = 0x115
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xb5296(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb52e8(%rip), %rsi # 0x10ff98
movq 0xb5251(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movq %rax, %r14
movq (%rbx), %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/PlainObjectBase.h
|
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::IndexedView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, 4, 1, 0, 4, 1>, Eigen::internal::AllRange<-1>>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::IndexedView<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<int, 4, 1, 0, 4, 1>, Eigen::internal::AllRange<-1>> const&, Eigen::internal::assign_op<double, double> const&)
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
// we need to resize the destination after the source evaluator has been created.
resize_if_allowed(dst, src, func);
DstEvaluatorType dstEvaluator(dst);
typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
dense_assignment_loop<Kernel>::run(kernel);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq 0x20(%rsi), %r14
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq $0x4, 0x8(%rdi)
jne 0x5aea1
cmpq %r14, 0x10(%r15)
jne 0x5aea1
movb $0x1, %dl
movl $0x4, %eax
movq %r14, %rcx
jmp 0x5aede
testq %r14, %r14
js 0x5af7e
movq %r14, %rax
shrq $0x3d, %rax
jne 0x5af9d
leaq (,%r14,4), %rsi
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x3e05a
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
cmpq $0x4, %rax
sete %dl
testb %dl, %dl
je 0x5af5f
cmpq %r14, %rcx
jne 0x5af5f
testq %r14, %r14
jle 0x5af36
movq (%r15), %rcx
leaq (,%rax,8), %rdx
xorl %esi, %esi
testq %rax, %rax
jle 0x5af2b
movq %rsi, %rdi
imulq %r13, %rdi
leaq (%r12,%rdi,8), %rdi
xorl %r8d, %r8d
cmpq $0x4, %r8
je 0x5af40
movslq 0x10(%rbx,%r8,4), %r9
movsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%rcx,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x5af0c
incq %rsi
addq %rdx, %rcx
cmpq %r14, %rsi
jne 0x5aef9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x5882c(%rip), %rdi # 0xb3773
leaq 0x58842(%rip), %rsi # 0xb3790
leaq 0x78739(%rip), %rcx # 0xd368e
movl $0xa3, %edx
callq 0x143c0
leaq 0x56000(%rip), %rdi # 0xb0f66
leaq 0x56028(%rip), %rsi # 0xb0f95
leaq 0x785eb(%rip), %rcx # 0xd355f
movl $0x2fd, %edx # imm = 0x2FD
callq 0x143c0
leaq 0x55c0b(%rip), %rdi # 0xb0b90
leaq 0x55d93(%rip), %rsi # 0xb0d1f
leaq 0x55dfd(%rip), %rcx # 0xb0d90
movl $0x115, %edx # imm = 0x115
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xb4f8a(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb4fdc(%rip), %rsi # 0x10ff98
movq 0xb4f45(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h
|
Eigen::internal::product_evaluator<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>, 7, Eigen::DenseShape, Eigen::DenseShape, double, double>::product_evaluator(Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0> const&)
|
void run(DstXprType &dst, const SrcXprType &src, const internal::assign_op<Scalar,Scalar> &)
{
Index dstRows = src.rows();
Index dstCols = src.cols();
if((dst.rows()!=dstRows) || (dst.cols()!=dstCols))
dst.resize(dstRows, dstCols);
// FIXME shall we handle nested_eval here?
generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), src.rhs());
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, (%rdi)
movq 0x8(%rsi), %rax
movq 0x10(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
testq %rcx, %rcx
js 0x5b055
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x5b0a8
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rdx
movq %rdi, (%r15)
testq %rdx, %rdx
js 0x5b074
movq 0x8(%r14), %r15
je 0x5b02b
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x14330
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5b150
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x55b34(%rip), %rdi # 0xb0b90
leaq 0x55cbc(%rip), %rsi # 0xb0d1f
leaq 0x78c4c(%rip), %rcx # 0xd3cb6
movl $0x115, %edx # imm = 0x115
callq 0x143c0
leaq 0x56c51(%rip), %rdi # 0xb1ccc
leaq 0x56cdf(%rip), %rsi # 0xb1d61
leaq 0x78ca6(%rip), %rcx # 0xd3d2f
movl $0x4a, %edx
callq 0x143c0
jmp 0x5b095
movq %rax, %r14
movq (%rbx), %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
Eigen::DenseStorage<double, -1, 1, -1, 1>::resize(long, long, long)
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void resize(Index size, Index, Index cols)
{
if(size != _Rows*m_cols)
{
internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, _Rows*m_cols);
if (size>0) // >0 and not simply !=0 to let the compiler knows that size cannot be negative
m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
else
m_data = 0;
EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN({})
}
m_cols = cols;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
cmpq %rsi, 0x8(%rdi)
je 0x5b127
movq %rsi, %r15
movq (%r14), %rdi
callq 0x14720
testq %r15, %r15
jle 0x5b122
movq %r15, %rax
shrq $0x3d, %rax
jne 0x5b0f4
leaq (,%r15,8), %rdi
callq 0x147f0
cmpq $0x1, %r15
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x5b131
testq %rax, %rax
jne 0x5b124
movl $0x8, %edi
callq 0x14290
movq 0xb4e33(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb4e85(%rip), %rsi # 0x10ff98
movq 0xb4dee(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
xorl %eax, %eax
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x55cd3(%rip), %rdi # 0xb0e0b
leaq 0x55d87(%rip), %rsi # 0xb0ec6
leaq 0x55ded(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/DenseStorage.h
|
void Eigen::internal::generic_product_impl<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Matrix<double, 1, -1, 1, 1, -1>>(Eigen::Matrix<double, 1, -1, 1, 1, -1>&, Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, double const&)
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rhs.col(0));
return;
}
LhsNested actual_lhs(lhs);
RhsNested actual_rhs(rhs);
internal::gemv_dense_selector<Side,
(int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
>::run(actual_lhs, actual_rhs, dst, alpha);
}
|
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
cmpq $0x1, 0x10(%rdx)
jne 0x5b22b
movq (%rsi), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
testq %rsi, %rsi
sete %r8b
testq %rax, %rax
setns %r9b
orb %r8b, %r9b
je 0x5b26f
movq (%rdx), %r8
movq 0x8(%rdx), %r9
testq %r8, %r8
sete %r10b
testq %r9, %r9
setns %r11b
orb %r10b, %r11b
je 0x5b286
cmpq %r9, %rax
jne 0x5b2a5
movsd (%rcx), %xmm1
movq %rsi, 0x10(%rsp)
movq %rdi, 0x28(%rsp)
movq $0x0, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq %rax, 0x20(%rsp)
movq %r8, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq %rdx, 0x60(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x68(%rsp)
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x5b253
movsd %xmm1, (%rsp)
jle 0x5b2c4
leaq 0x88(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5b2e4
movsd (%rsp), %xmm1
jmp 0x5b257
movq (%rsi), %r8
leaq 0x10(%rsp), %rax
movq %rbx, (%rax)
leaq 0x88(%rsp), %rdi
movq %rdx, (%rdi)
leaq 0x8(%rsp), %rsi
movq %r8, (%rsi)
movq %rax, %rdx
callq 0x5b3c8
jmp 0x5b266
xorpd %xmm0, %xmm0
mulsd %xmm0, %xmm1
movq (%rbx), %rax
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
addq $0xc0, %rsp
popq %rbx
retq
leaq 0x56063(%rip), %rdi # 0xb12d9
leaq 0x56106(%rip), %rsi # 0xb1383
leaq 0x78ba2(%rip), %rcx # 0xd3e26
jmp 0x5b29b
leaq 0x5604c(%rip), %rdi # 0xb12d9
leaq 0x560ef(%rip), %rsi # 0xb1383
leaq 0x5655c(%rip), %rcx # 0xb17f7
movl $0xb2, %edx
callq 0x143c0
leaq 0x56f8f(%rip), %rdi # 0xb223b
leaq 0x56f9f(%rip), %rsi # 0xb2252
leaq 0x78c57(%rip), %rcx # 0xd3f11
movl $0x52, %edx
callq 0x143c0
leaq 0x55661(%rip), %rdi # 0xb092c
leaq 0x5569e(%rip), %rsi # 0xb0970
leaq 0x78dfa(%rip), %rcx # 0xd40d3
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const, 1, -1, true> const> const, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const>>, 3, 0>::run<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const, 1, -1, true> const> const, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const>>(Eigen::internal::redux_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const, 1, -1, true> const> const, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const>> const&, Eigen::internal::scalar_sum_op<double, double> const&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const, 1, -1, true> const> const, Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1> const, -1, 1, true> const> const&)
|
explicit variable_if_dynamic(T value = 0) EIGEN_NO_THROW : m_value(value) {}
|
movq 0x40(%rdx), %rax
leaq 0x3(%rax), %r8
testq %rax, %rax
cmovnsq %rax, %r8
leaq 0x1(%rax), %rsi
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
cmpq $0x3, %rsi
jae 0x5b30e
movsd (%rdx), %xmm0
mulsd (%rcx), %xmm0
retq
movq %rax, %rsi
shrq $0x3f, %rsi
addq %rax, %rsi
andq $-0x2, %rsi
movupd (%rdx), %xmm0
movupd (%rcx), %xmm1
mulpd %xmm0, %xmm1
cmpq $0x4, %rax
jl 0x5b39f
andq $-0x4, %r8
movupd 0x10(%rdx), %xmm2
movupd 0x10(%rcx), %xmm0
mulpd %xmm2, %xmm0
cmpq $0x8, %rax
jb 0x5b37a
movl $0x4, %edi
movupd (%rdx,%rdi,8), %xmm2
movupd 0x10(%rdx,%rdi,8), %xmm3
movupd (%rcx,%rdi,8), %xmm4
mulpd %xmm2, %xmm4
addpd %xmm4, %xmm1
movupd 0x10(%rcx,%rdi,8), %xmm2
mulpd %xmm3, %xmm2
addpd %xmm2, %xmm0
addq $0x4, %rdi
cmpq %r8, %rdi
jl 0x5b34b
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
addpd %xmm2, %xmm1
cmpq %r8, %rsi
jle 0x5b39f
movupd (%rdx,%r8,8), %xmm0
movupd (%rcx,%r8,8), %xmm2
mulpd %xmm0, %xmm2
addpd %xmm2, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cmpq %rax, %rsi
jge 0x5b3c6
movsd (%rdx,%rsi,8), %xmm1
mulsd (%rcx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x5b3b0
retq
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/util/XprHelper.h
|
void Eigen::internal::gemv_dense_selector<2, 1, true>::run<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1> const>, Eigen::Transpose<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const>, Eigen::Transpose<Eigen::Matrix<double, 1, -1, 1, 1, -1>>>(Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1> const> const&, Eigen::Transpose<Eigen::Transpose<Eigen::Matrix<double, -1, 1, 0, -1, 1>> const> const&, Eigen::Transpose<Eigen::Matrix<double, 1, -1, 1, 1, -1>>&, Eigen::Transpose<Eigen::Matrix<double, 1, -1, 1, 1, -1>>::Scalar const&)
|
static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
{
typedef typename Lhs::Scalar LhsScalar;
typedef typename Rhs::Scalar RhsScalar;
typedef typename Dest::Scalar ResScalar;
typedef internal::blas_traits<Lhs> LhsBlasTraits;
typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
typedef internal::blas_traits<Rhs> RhsBlasTraits;
typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);
enum {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1 || ActualRhsTypeCleaned::MaxSizeAtCompileTime==0
};
gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
if(!DirectlyUseRhs)
{
#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
#endif
Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
}
typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
general_matrix_vector_product
<Index,LhsScalar,LhsMapper,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
actualLhs.rows(), actualLhs.cols(),
LhsMapper(actualLhs.data(), actualLhs.outerStride()),
RhsMapper(actualRhsPtr, 1),
dest.data(), dest.col(0).innerStride(), //NOTE if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166)
actualAlpha);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq (%rsi), %rax
movq 0x8(%rax), %r15
movq %r15, %rdx
shrq $0x3d, %rdx
jne 0x5b4b0
movq (%rdi), %r12
movsd (%rcx), %xmm0
movq (%rax), %rax
testq %rax, %rax
je 0x5b401
xorl %ebx, %ebx
jmp 0x5b44b
leaq (,%r15,8), %rdi
cmpq $0x4000, %r15 # imm = 0x4000
ja 0x5b428
movq %rsp, %rbx
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rbx
movq %rbx, %rsp
movq %rbx, %rax
jmp 0x5b44b
movsd %xmm0, -0x28(%rbp)
callq 0x147f0
movq %rax, %rbx
testb $0xf, %bl
jne 0x5b4fd
movq %rbx, %rax
testq %rbx, %rbx
movsd -0x28(%rbp), %xmm0
je 0x5b4b0
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdi
movq (%r12), %rcx
movq %rcx, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq $0x1, -0x30(%rbp)
movq (%r14), %rax
movq (%rax), %r8
testq %r8, %r8
je 0x5b47f
cmpq $0x0, 0x8(%rax)
js 0x5b4de
leaq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movl $0x1, %r9d
callq 0x3f440
cmpq $0x4001, %r15 # imm = 0x4001
jb 0x5b4a3
movq %rbx, %rdi
callq 0x14720
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x14290
movq 0xb4a77(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb4ac9(%rip), %rsi # 0x10ff98
movq 0xb4a32(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0x55df4(%rip), %rdi # 0xb12d9
leaq 0x55e97(%rip), %rsi # 0xb1383
leaq 0x78e6d(%rip), %rcx # 0xd4360
movl $0xb2, %edx
callq 0x143c0
leaq 0x55907(%rip), %rdi # 0xb0e0b
leaq 0x559bb(%rip), %rsi # 0xb0ec6
leaq 0x55a21(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
movq %rax, %r14
cmpq $0x4001, %r15 # imm = 0x4001
jb 0x5b530
movq %rbx, %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/GeneralProduct.h
|
void Eigen::internal::call_assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0> const&, Eigen::internal::assign_op<double, double> const&, Eigen::internal::enable_if<evaluator_assume_aliasing<Eigen::Product<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, 0>>::value, void*>::type)
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
void call_assignment(Dst& dst, const Src& src, const Func& func, typename enable_if< evaluator_assume_aliasing<Src>::value, void*>::type = 0)
{
typename plain_matrix_type<Src>::type tmp(src);
call_assignment_no_alias(dst, tmp, func);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rsi), %rax
movq 0x10(%rax), %r12
testq %r12, %r12
je 0x5b79d
js 0x5b87c
movq %r12, %rax
shrq $0x3d, %rax
jne 0x5b84e
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x147f0
cmpq $0x1, %r12
setne %cl
testb $0xf, %al
setne %dl
testb %dl, %cl
jne 0x5b89b
testq %rax, %rax
je 0x5b84e
movq %rax, (%rsp)
movq %r12, 0x8(%rsp)
movq 0x8(%r14), %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x14330
jmp 0x5b7a1
movq 0x8(%r14), %r12
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rsp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5b8f0
movq (%rsp), %r15
movq 0x8(%rsp), %r14
cmpq %r14, 0x8(%rbx)
je 0x5b7f6
testq %r14, %r14
js 0x5b87c
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x4476c
cmpq %r14, 0x8(%rbx)
jne 0x5b8ba
movq (%rbx), %rax
movq %r14, %rcx
shrq $0x3f, %rcx
addq %r14, %rcx
andq $-0x2, %rcx
cmpq $0x2, %r14
jl 0x5b821
xorl %edx, %edx
movaps (%r15,%rdx,8), %xmm0
movaps %xmm0, (%rax,%rdx,8)
addq $0x2, %rdx
cmpq %rcx, %rdx
jl 0x5b80f
cmpq %r14, %rcx
jge 0x5b839
movsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x5b826
movq (%rsp), %rdi
callq 0x14720
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x8, %edi
callq 0x14290
movq 0xb46d9(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb472b(%rip), %rsi # 0x10ff98
movq 0xb4694(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0x5530d(%rip), %rdi # 0xb0b90
leaq 0x55495(%rip), %rsi # 0xb0d1f
leaq 0x5ab33(%rip), %rcx # 0xb63c4
movl $0x115, %edx # imm = 0x115
callq 0x143c0
leaq 0x55569(%rip), %rdi # 0xb0e0b
leaq 0x5561d(%rip), %rsi # 0xb0ec6
leaq 0x55683(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
leaq 0x556a5(%rip), %rdi # 0xb0f66
leaq 0x556cd(%rip), %rsi # 0xb0f95
leaq 0x779f1(%rip), %rcx # 0xd32c0
movl $0x2fd, %edx # imm = 0x2FD
callq 0x143c0
jmp 0x5b8db
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x14720
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h
|
void Eigen::internal::generic_product_impl<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, double const&)
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rhs.col(0));
return;
}
LhsNested actual_lhs(lhs);
RhsNested actual_rhs(rhs);
internal::gemv_dense_selector<Side,
(int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
>::run(actual_lhs, actual_rhs, dst, alpha);
}
|
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
movq (%rsi), %r9
cmpq $0x1, 0x10(%r9)
jne 0x5b9cd
movq (%r9), %rsi
movq 0x8(%r9), %rax
testq %rsi, %rsi
sete %dil
testq %rax, %rax
setns %r8b
orb %dil, %r8b
je 0x5b9fe
movq (%rdx), %r8
movq 0x8(%rdx), %rdi
testq %r8, %r8
sete %r10b
testq %rdi, %rdi
setns %r11b
orb %r10b, %r11b
je 0x5ba15
cmpq %rdi, %rax
jne 0x5ba34
movsd (%rcx), %xmm1
movq %rsi, 0x10(%rsp)
movq %r9, 0x28(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x30(%rsp)
movq %rax, 0x40(%rsp)
movq %rax, 0x20(%rsp)
movq %r8, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq %rdx, 0x60(%rsp)
movq $0x0, 0x68(%rsp)
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x5b9e2
movsd %xmm1, 0x8(%rsp)
jle 0x5ba53
leaq 0x88(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x7(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x5bbdc
movsd 0x8(%rsp), %xmm1
jmp 0x5b9e6
leaq 0x10(%rsp), %rdi
movq %r9, (%rdi)
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x5ba72
jmp 0x5b9f5
xorpd %xmm0, %xmm0
mulsd %xmm0, %xmm1
movq (%rbx), %rax
addsd (%rax), %xmm1
movsd %xmm1, (%rax)
addq $0xc0, %rsp
popq %rbx
retq
leaq 0x558d4(%rip), %rdi # 0xb12d9
leaq 0x55977(%rip), %rsi # 0xb1383
leaq 0x78fe5(%rip), %rcx # 0xd49f8
jmp 0x5ba2a
leaq 0x558bd(%rip), %rdi # 0xb12d9
leaq 0x55960(%rip), %rsi # 0xb1383
leaq 0x7950b(%rip), %rcx # 0xd4f35
movl $0xb2, %edx
callq 0x143c0
leaq 0x56800(%rip), %rdi # 0xb223b
leaq 0x56810(%rip), %rsi # 0xb2252
leaq 0x7909c(%rip), %rcx # 0xd4ae5
movl $0x52, %edx
callq 0x143c0
leaq 0x54ed2(%rip), %rdi # 0xb092c
leaq 0x54f0f(%rip), %rsi # 0xb0970
leaq 0x79240(%rip), %rcx # 0xd4ca8
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
void Eigen::internal::gemv_dense_selector<2, 1, true>::run<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>::Scalar const&)
|
static void run(const Lhs &lhs, const Rhs &rhs, Dest& dest, const typename Dest::Scalar& alpha)
{
typedef typename Lhs::Scalar LhsScalar;
typedef typename Rhs::Scalar RhsScalar;
typedef typename Dest::Scalar ResScalar;
typedef internal::blas_traits<Lhs> LhsBlasTraits;
typedef typename LhsBlasTraits::DirectLinearAccessType ActualLhsType;
typedef internal::blas_traits<Rhs> RhsBlasTraits;
typedef typename RhsBlasTraits::DirectLinearAccessType ActualRhsType;
typedef typename internal::remove_all<ActualRhsType>::type ActualRhsTypeCleaned;
typename add_const<ActualLhsType>::type actualLhs = LhsBlasTraits::extract(lhs);
typename add_const<ActualRhsType>::type actualRhs = RhsBlasTraits::extract(rhs);
ResScalar actualAlpha = combine_scalar_factors(alpha, lhs, rhs);
enum {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
DirectlyUseRhs = ActualRhsTypeCleaned::InnerStrideAtCompileTime==1 || ActualRhsTypeCleaned::MaxSizeAtCompileTime==0
};
gemv_static_vector_if<RhsScalar,ActualRhsTypeCleaned::SizeAtCompileTime,ActualRhsTypeCleaned::MaxSizeAtCompileTime,!DirectlyUseRhs> static_rhs;
ei_declare_aligned_stack_constructed_variable(RhsScalar,actualRhsPtr,actualRhs.size(),
DirectlyUseRhs ? const_cast<RhsScalar*>(actualRhs.data()) : static_rhs.data());
if(!DirectlyUseRhs)
{
#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
#endif
Map<typename ActualRhsTypeCleaned::PlainObject>(actualRhsPtr, actualRhs.size()) = actualRhs;
}
typedef const_blas_data_mapper<LhsScalar,Index,RowMajor> LhsMapper;
typedef const_blas_data_mapper<RhsScalar,Index,ColMajor> RhsMapper;
general_matrix_vector_product
<Index,LhsScalar,LhsMapper,RowMajor,LhsBlasTraits::NeedToConjugate,RhsScalar,RhsMapper,RhsBlasTraits::NeedToConjugate>::run(
actualLhs.rows(), actualLhs.cols(),
LhsMapper(actualLhs.data(), actualLhs.outerStride()),
RhsMapper(actualRhsPtr, 1),
dest.data(), dest.col(0).innerStride(), //NOTE if dest is not a vector at compile-time, then dest.innerStride() might be wrong. (bug 1166)
actualAlpha);
}
|
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq 0x8(%rsi), %r15
movq %r15, %rax
shrq $0x3d, %rax
jne 0x5bb54
movq %rdx, %r14
movq (%rdi), %r12
movsd (%rcx), %xmm0
movq (%rsi), %rax
testq %rax, %rax
je 0x5baa8
xorl %ebx, %ebx
jmp 0x5baf2
leaq (,%r15,8), %rdi
cmpq $0x4000, %r15 # imm = 0x4000
ja 0x5bacf
movq %rsp, %rbx
addq $0x1e, %rdi
andq $-0x10, %rdi
subq %rdi, %rbx
movq %rbx, %rsp
movq %rbx, %rax
jmp 0x5baf2
movsd %xmm0, -0x28(%rbp)
callq 0x147f0
movq %rax, %rbx
testb $0xf, %bl
jne 0x5bba1
movq %rbx, %rax
testq %rbx, %rbx
movsd -0x28(%rbp), %xmm0
je 0x5bb54
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdi
movq (%r12), %rcx
movq %rcx, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq $0x1, -0x30(%rbp)
movq (%r14), %r8
testq %r8, %r8
je 0x5bb23
cmpq $0x0, 0x8(%r14)
js 0x5bb82
leaq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rcx
movl $0x1, %r9d
callq 0x3f440
cmpq $0x4001, %r15 # imm = 0x4001
jb 0x5bb47
movq %rbx, %rdi
callq 0x14720
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %edi
callq 0x14290
movq 0xb43d3(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb4425(%rip), %rsi # 0x10ff98
movq 0xb438e(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
leaq 0x55750(%rip), %rdi # 0xb12d9
leaq 0x557f3(%rip), %rsi # 0xb1383
leaq 0x79465(%rip), %rcx # 0xd4ffc
movl $0xb2, %edx
callq 0x143c0
leaq 0x55263(%rip), %rdi # 0xb0e0b
leaq 0x55317(%rip), %rsi # 0xb0ec6
leaq 0x5537d(%rip), %rcx # 0xb0f33
movl $0xb9, %edx
callq 0x143c0
movq %rax, %r14
cmpq $0x4001, %r15 # imm = 0x4001
jb 0x5bbd4
movq %rbx, %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/GeneralProduct.h
|
double Eigen::internal::redux_impl<Eigen::internal::scalar_sum_op<double, double>, Eigen::internal::redux_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const, 1, -1, true> const> const, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, -1, 1, true> const>>, 3, 0>::run<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const, 1, -1, true> const> const, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, -1, 1, true> const>>(Eigen::internal::redux_evaluator<Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const, 1, -1, true> const> const, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, -1, 1, true> const>> const&, Eigen::internal::scalar_sum_op<double, double> const&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_conj_product_op<double, double>, Eigen::Transpose<Eigen::Block<Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const, 1, -1, true> const> const, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1> const, -1, 1, true> const> const&)
|
T value() const { return m_value; }
|
movq 0x40(%rdx), %rax
leaq 0x3(%rax), %r8
testq %rax, %rax
cmovnsq %rax, %r8
leaq 0x1(%rax), %rsi
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
cmpq $0x3, %rsi
jae 0x5bc06
movsd (%rdx), %xmm0
mulsd (%rcx), %xmm0
retq
movq %rax, %rsi
shrq $0x3f, %rsi
addq %rax, %rsi
andq $-0x2, %rsi
movupd (%rdx), %xmm0
movupd (%rcx), %xmm1
mulpd %xmm0, %xmm1
cmpq $0x4, %rax
jl 0x5bc97
andq $-0x4, %r8
movupd 0x10(%rdx), %xmm2
movupd 0x10(%rcx), %xmm0
mulpd %xmm2, %xmm0
cmpq $0x8, %rax
jb 0x5bc72
movl $0x4, %edi
movupd (%rdx,%rdi,8), %xmm2
movupd 0x10(%rdx,%rdi,8), %xmm3
movupd (%rcx,%rdi,8), %xmm4
mulpd %xmm2, %xmm4
addpd %xmm4, %xmm1
movupd 0x10(%rcx,%rdi,8), %xmm2
mulpd %xmm3, %xmm2
addpd %xmm2, %xmm0
addq $0x4, %rdi
cmpq %r8, %rdi
jl 0x5bc43
movapd %xmm1, %xmm2
movapd %xmm0, %xmm1
addpd %xmm2, %xmm1
cmpq %r8, %rsi
jle 0x5bc97
movupd (%rdx,%r8,8), %xmm0
movupd (%rcx,%r8,8), %xmm2
mulpd %xmm0, %xmm2
addpd %xmm2, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
cmpq %rax, %rsi
jge 0x5bcbe
movsd (%rdx,%rsi,8), %xmm1
mulsd (%rcx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x5bca8
retq
nop
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/util/XprHelper.h
|
Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::PlainObjectBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>>(Eigen::DenseBase<Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>> const&)
|
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE PlainObjectBase(const DenseBase<OtherDerived> &other)
: m_storage()
{
_check_template_params();
resizeLike(other);
_set_noalias(other);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r8
movq 0x8(%rsi), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %dl
orb %al, %dl
jne 0x5bd03
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x5bd54
movq %rcx, %rax
orq %r8, %rax
js 0x5bd35
movq %rcx, %rsi
imulq %r8, %rsi
movq %rbx, %rdi
movq %r8, %rdx
callq 0x3e05a
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5bd95
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x54e54(%rip), %rdi # 0xb0b90
leaq 0x54fdc(%rip), %rsi # 0xb0d1f
leaq 0x55046(%rip), %rcx # 0xb0d90
movl $0x115, %edx # imm = 0x115
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xb41d3(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb4225(%rip), %rsi # 0x10ff98
movq 0xb418e(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
movq %rax, %r14
movq (%rbx), %rdi
callq 0x14720
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/PlainObjectBase.h
|
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<double>, Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&, Eigen::internal::assign_op<double, double> const&)
|
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose())/s with A rectangular,
// we need to resize the destination after the source evaluator has been created.
resize_if_allowed(dst, src, func);
DstEvaluatorType dstEvaluator(dst);
typedef generic_dense_assignment_kernel<DstEvaluatorType,SrcEvaluatorType,Functor> Kernel;
Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
dense_assignment_loop<Kernel>::run(kernel);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq (%rsi), %rbx
movq 0x8(%rsi), %r14
cmpq %rbx, 0x8(%rdi)
jne 0x5bdb6
movq %r14, %rax
movq %rbx, %rcx
cmpq %r14, 0x10(%r15)
je 0x5be07
movq %r14, %rax
orq %rbx, %rax
js 0x5bf39
testq %rbx, %rbx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x5bdea
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %r14
cmpq %rbx, %rax
jl 0x5bf58
movq %r14, %rsi
imulq %rbx, %rsi
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x3e05a
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rax
cmpq %rbx, %rcx
jne 0x5bf1a
cmpq %r14, %rax
jne 0x5bf1a
testq %r14, %r14
jle 0x5bf14
movq (%r15), %rax
leaq 0x1(%rbx), %rcx
andq $-0x2, %rcx
leaq -0x1(%rbx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x8, %rax
leaq (,%rbx,8), %rdx
xorl %esi, %esi
movdqa 0x5322f(%rip), %xmm1 # 0xaf080
movdqa 0x53237(%rip), %xmm2 # 0xaf090
pxor %xmm2, %xmm0
movq 0x531a3(%rip), %xmm3 # 0xaf008
pcmpeqd %xmm4, %xmm4
movdqa 0x7185f(%rip), %xmm5 # 0xcd6d0
testq %rbx, %rbx
jle 0x5bf05
leaq -0x1(%rsi), %rdi
xorl %r8d, %r8d
movdqa %xmm1, %xmm6
movdqa %xmm6, %xmm7
pxor %xmm2, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm0, %xmm8
pcmpeqd %xmm0, %xmm7
pshufd $0xf5, %xmm7, %xmm9 # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7 # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %r9d
notl %r9d
testb $0x1, %r9b
je 0x5bed5
movdqa %xmm3, %xmm8
cmpq %r8, %rsi
je 0x5bece
pxor %xmm8, %xmm8
movq %xmm8, -0x8(%rax,%r8,8)
pxor %xmm4, %xmm7
pextrw $0x4, %xmm7, %r9d
testb $0x1, %r9b
je 0x5bef8
movdqa %xmm3, %xmm7
cmpq %r8, %rdi
je 0x5bef2
pxor %xmm7, %xmm7
movq %xmm7, (%rax,%r8,8)
addq $0x2, %r8
paddq %xmm5, %xmm6
cmpq %r8, %rcx
jne 0x5be85
incq %rsi
addq %rdx, %rax
cmpq %r14, %rsi
jne 0x5be71
popq %rbx
popq %r14
popq %r15
retq
leaq 0x55045(%rip), %rdi # 0xb0f66
leaq 0x5506d(%rip), %rsi # 0xb0f95
leaq 0x79284(%rip), %rcx # 0xd51b3
movl $0x2fd, %edx # imm = 0x2FD
callq 0x143c0
leaq 0x54c50(%rip), %rdi # 0xb0b90
leaq 0x54dd8(%rip), %rsi # 0xb0d1f
leaq 0x54e42(%rip), %rcx # 0xb0d90
movl $0x115, %edx # imm = 0x115
callq 0x143c0
movl $0x8, %edi
callq 0x14290
movq 0xb3fcf(%rip), %rcx # 0x10ff38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0xb4021(%rip), %rsi # 0x10ff98
movq 0xb3f8a(%rip), %rdx # 0x10ff08
movq %rax, %rdi
callq 0x14a60
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/AssignEvaluator.h
|
void Eigen::internal::generic_product_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::DenseShape, Eigen::DenseShape, 7>::scaleAndAddTo<Eigen::Matrix<double, -1, 1, 0, -1, 1>>(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, double const&)
|
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void scaleAndAddTo(Dest& dst, const Lhs& lhs, const Rhs& rhs, const Scalar& alpha)
{
// Fallback to inner product if both the lhs and rhs is a runtime vector.
if (lhs.rows() == 1 && rhs.cols() == 1) {
dst.coeffRef(0,0) += alpha * lhs.row(0).conjugate().dot(rhs.col(0));
return;
}
LhsNested actual_lhs(lhs);
RhsNested actual_rhs(rhs);
internal::gemv_dense_selector<Side,
(int(MatrixType::Flags)&RowMajorBit) ? RowMajor : ColMajor,
bool(internal::blas_traits<MatrixType>::HasUsableDirectAccess)
>::run(actual_lhs, actual_rhs, dst, alpha);
}
|
subq $0x28, %rsp
movq 0x8(%rsi), %rax
movsd (%rcx), %xmm0
cmpq $0x1, %rax
jne 0x5c68f
movq (%rsi), %rax
movq 0x10(%rsi), %rcx
testq %rax, %rax
sete %sil
testq %rcx, %rcx
setns %r8b
orb %sil, %r8b
je 0x5c6e6
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
testq %rsi, %rsi
sete %r8b
testq %rdx, %rdx
setns %r9b
orb %r8b, %r9b
je 0x5c6fd
cmpq %rdx, %rcx
jne 0x5c71c
testq %rcx, %rcx
je 0x5c6ce
jle 0x5c73b
movsd (%rax), %xmm1
mulsd (%rsi), %xmm1
cmpq $0x1, %rcx
je 0x5c6d2
movl $0x1, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd (%rsi,%rdx,8), %xmm2
addsd %xmm2, %xmm1
incq %rdx
cmpq %rdx, %rcx
jne 0x5c677
jmp 0x5c6d2
movq 0x10(%rsi), %r10
movq (%rsi), %rcx
leaq 0x18(%rsp), %r11
movq %rcx, (%r11)
movq %rax, 0x8(%r11)
movq (%rdx), %rdx
leaq 0x8(%rsp), %rcx
movq %rdx, (%rcx)
movq $0x1, 0x8(%rcx)
movq (%rdi), %r8
movl $0x1, %r9d
movq %rax, %rdi
movq %r10, %rsi
movq %r11, %rdx
callq 0x3ece6
jmp 0x5c6e1
xorpd %xmm1, %xmm1
movq (%rdi), %rax
mulsd %xmm1, %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
addq $0x28, %rsp
retq
leaq 0x54bec(%rip), %rdi # 0xb12d9
leaq 0x54c8f(%rip), %rsi # 0xb1383
leaq 0x54cf1(%rip), %rcx # 0xb13ec
jmp 0x5c712
leaq 0x54bd5(%rip), %rdi # 0xb12d9
leaq 0x54c78(%rip), %rsi # 0xb1383
leaq 0x78823(%rip), %rcx # 0xd4f35
movl $0xb2, %edx
callq 0x143c0
leaq 0x55b18(%rip), %rdi # 0xb223b
leaq 0x55b28(%rip), %rsi # 0xb2252
leaq 0x78e14(%rip), %rcx # 0xd5545
movl $0x52, %edx
callq 0x143c0
leaq 0x541ea(%rip), %rdi # 0xb092c
leaq 0x54227(%rip), %rsi # 0xb0970
leaq 0x78f80(%rip), %rcx # 0xd56d0
movl $0x19b, %edx # imm = 0x19B
callq 0x143c0
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/ProductEvaluators.h
|
double Eigen::internal::redux_impl<Eigen::internal::scalar_max_op<double, double, 0>, Eigen::internal::redux_evaluator<Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>>, 3, 0>::run<Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>>(Eigen::internal::redux_evaluator<Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false>> const&, Eigen::internal::scalar_max_op<double, double, 0> const&, Eigen::Block<Eigen::Matrix<double, -1, 1, 0, -1, 1>, -1, 1, false> const&)
|
static Scalar run(const Evaluator &eval, const Func& func, const XprType& xpr)
{
const Index size = xpr.size();
const Index packetSize = redux_traits<Func, Evaluator>::PacketSize;
const int packetAlignment = unpacket_traits<PacketScalar>::alignment;
enum {
alignment0 = (bool(Evaluator::Flags & DirectAccessBit) && bool(packet_traits<Scalar>::AlignedOnScalar)) ? int(packetAlignment) : int(Unaligned),
alignment = EIGEN_PLAIN_ENUM_MAX(alignment0, Evaluator::Alignment)
};
const Index alignedStart = internal::first_default_aligned(xpr);
const Index alignedSize2 = ((size-alignedStart)/(2*packetSize))*(2*packetSize);
const Index alignedSize = ((size-alignedStart)/(packetSize))*(packetSize);
const Index alignedEnd2 = alignedStart + alignedSize2;
const Index alignedEnd = alignedStart + alignedSize;
Scalar res;
if(alignedSize)
{
PacketScalar packet_res0 = eval.template packet<alignment,PacketScalar>(alignedStart);
if(alignedSize>packetSize) // we have at least two packets to partly unroll the loop
{
PacketScalar packet_res1 = eval.template packet<alignment,PacketScalar>(alignedStart+packetSize);
for(Index index = alignedStart + 2*packetSize; index < alignedEnd2; index += 2*packetSize)
{
packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment,PacketScalar>(index));
packet_res1 = func.packetOp(packet_res1, eval.template packet<alignment,PacketScalar>(index+packetSize));
}
packet_res0 = func.packetOp(packet_res0,packet_res1);
if(alignedEnd>alignedEnd2)
packet_res0 = func.packetOp(packet_res0, eval.template packet<alignment,PacketScalar>(alignedEnd2));
}
res = func.predux(packet_res0);
for(Index index = 0; index < alignedStart; ++index)
res = func(res,eval.coeff(index));
for(Index index = alignedEnd; index < size; ++index)
res = func(res,eval.coeff(index));
}
else // too small to vectorize anything.
// since this is dynamic-size hence inefficient anyway for such small sizes, don't try to optimize.
{
res = eval.coeff(0);
for(Index index = 1; index < size; ++index)
res = func(res,eval.coeff(index));
}
return res;
}
|
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
movq %rax, %rsi
testb $0x7, %cl
jne 0x5c779
shrl $0x3, %ecx
andl $0x1, %ecx
cmpq %rax, %rcx
cmovgeq %rax, %rcx
movq %rcx, %rsi
movq %rax, %r9
subq %rsi, %r9
leaq 0x3(%r9), %r8
testq %r9, %r9
cmovnsq %r9, %r8
leaq 0x1(%r9), %rdx
movq (%rdi), %rcx
cmpq $0x3, %rdx
jae 0x5c7c4
movsd (%rcx), %xmm1
cmpq $0x2, %rax
jl 0x5c888
movl $0x1, %edx
movsd (%rcx,%rdx,8), %xmm0
maxsd %xmm1, %xmm0
incq %rdx
movapd %xmm0, %xmm1
cmpq %rdx, %rax
jne 0x5c7aa
jmp 0x5c887
movq %r9, %rdx
shrq $0x3f, %rdx
addq %r9, %rdx
andq $-0x2, %rdx
movupd (%rcx,%rsi,8), %xmm0
cmpq $0x4, %r9
jl 0x5c83c
andq $-0x4, %r8
leaq (%r8,%rsi), %rdi
movupd 0x10(%rcx,%rsi,8), %xmm1
cmpq $0x8, %r9
jb 0x5c81b
leaq 0x4(%rsi), %r9
movups (%rcx,%r9,8), %xmm2
movups 0x10(%rcx,%r9,8), %xmm3
maxpd %xmm0, %xmm2
maxpd %xmm1, %xmm3
addq $0x4, %r9
movapd %xmm2, %xmm0
movapd %xmm3, %xmm1
cmpq %rdi, %r9
jl 0x5c7f5
jmp 0x5c823
movapd %xmm1, %xmm3
movapd %xmm0, %xmm2
movapd %xmm3, %xmm0
maxpd %xmm2, %xmm0
cmpq %r8, %rdx
jle 0x5c83c
movups (%rcx,%rdi,8), %xmm1
maxpd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq %rsi, %rdx
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2 # xmm2 = xmm2[1],xmm0[1]
maxsd %xmm0, %xmm2
testq %rsi, %rsi
jle 0x5c869
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm1
maxsd %xmm2, %xmm1
incq %rdi
movapd %xmm1, %xmm2
cmpq %rdi, %rsi
jne 0x5c852
jmp 0x5c86d
movapd %xmm2, %xmm1
cmpq %rax, %rdx
jge 0x5c888
movsd (%rcx,%rdx,8), %xmm0
maxsd %xmm1, %xmm0
incq %rdx
movapd %xmm0, %xmm1
cmpq %rax, %rdx
jl 0x5c872
retq
movapd %xmm1, %xmm0
retq
|
/ebu[P]libear/submodules/eigen/Eigen/src/Core/Redux.h
|
ear::GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(ear::PolarSpeakerPosition)
|
PolarSpeakerPosition GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(
PolarSpeakerPosition pos) {
std::tie(pos.azimuth, pos.elevation) =
_screenEdgeLockHandler.handleAzimuthElevation(
pos.azimuth, pos.elevation, pos.screenEdgeLock);
return pos;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movsd (%rdx), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rdx), %xmm0
movsd %xmm0, 0x8(%rsp)
movb $0x0, 0x18(%rsp)
cmpb $0x1, 0x78(%rdx)
jne 0x5e2a9
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, -0x18(%r12)
movb $0x0, 0x40(%rsp)
cmpb $0x1, 0xa0(%r14)
jne 0x5e2e1
leaq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xa8(%r14), %rsi
movq 0xb0(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0x40(%rsp)
subq $-0x80, %r15
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x60c82
movsd %xmm0, (%r14)
movsd %xmm1, 0x28(%r14)
cmpb $0x1, 0x40(%rsp)
jne 0x5e330
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e32b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x40(%rsp)
cmpb $0x1, 0x18(%rsp)
jne 0x5e352
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e352
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x145f0
movl $0xf, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rbx)
cmpb $0x1, 0x78(%r14)
jne 0x5e3cf
movl $0x90, %eax
leaq (%rbx,%rax), %rcx
movq %rcx, 0x80(%rbx)
movq 0x80(%r14), %rdx
addq %r14, %rax
cmpq %rax, %rdx
je 0x5e39d
movq %rdx, 0x80(%rbx)
movq (%rax), %rcx
movq %rcx, 0x90(%rbx)
jmp 0x5e3a3
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x88(%r14), %rcx
movq %rcx, 0x88(%rbx)
movq %rax, 0x80(%r14)
movq $0x0, 0x88(%r14)
movb $0x0, 0x90(%r14)
movb $0x1, 0x78(%rbx)
movb $0x0, 0xa0(%rbx)
cmpb $0x1, 0xa0(%r14)
jne 0x5e447
movl $0xb8, %eax
leaq (%rbx,%rax), %rcx
movq %rcx, 0xa8(%rbx)
movq 0xa8(%r14), %rdx
addq %r14, %rax
cmpq %rax, %rdx
je 0x5e412
movq %rdx, 0xa8(%rbx)
movq (%rax), %rcx
movq %rcx, 0xb8(%rbx)
jmp 0x5e418
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0xb0(%r14), %rcx
movq %rcx, 0xb0(%rbx)
movq %rax, 0xa8(%r14)
movq $0x0, 0xb0(%r14)
movb $0x0, 0xb8(%r14)
movb $0x1, 0xa0(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpb $0x1, 0x18(%rsp)
jne 0x5e48a
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e48a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x5e48a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x60d2c
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(ear::CartesianSpeakerPosition)
|
CartesianSpeakerPosition
GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(
CartesianSpeakerPosition pos) {
std::tie(pos.X, pos.Y, pos.Z) = _screenEdgeLockHandler.handleVector(
toCartesianVector3d(pos), pos.screenEdgeLock);
return pos;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x68(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rax)
cmpb $0x1, 0x78(%rdx)
jne 0x5e4f7
leaq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, -0x18(%r12)
movb $0x0, 0x108(%rsp)
cmpb $0x1, 0xa0(%r14)
jne 0x5e53b
leaq 0x110(%rsp), %rdi
leaq 0x120(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xa8(%r14), %rsi
movq 0xb0(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0x108(%rsp)
leaq 0x130(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4db66
movb $0x0, (%rsp)
cmpb $0x1, 0x78(%r14)
jne 0x5e580
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, (%rsp)
movb $0x0, 0x28(%rsp)
cmpb $0x1, 0xa0(%r14)
jne 0x5e5b8
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xa8(%r14), %rsi
movq 0xb0(%r14), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0x28(%rsp)
subq $-0x80, %r15
leaq 0x50(%rsp), %rdi
leaq 0x130(%rsp), %rdx
movq %rsp, %rcx
movq %r15, %rsi
callq 0x60d74
movsd 0x60(%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x28(%r14)
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x50(%r14)
cmpb $0x1, 0x28(%rsp)
jne 0x5e61e
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e619
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x28(%rsp)
cmpb $0x1, (%rsp)
jne 0x5e643
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e63f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, (%rsp)
cmpb $0x1, 0x108(%rsp)
jne 0x5e676
leaq 0x120(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e66e
movq 0x120(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x108(%rsp)
cmpb $0x1, 0xe0(%rsp)
jne 0x5e6a1
leaq 0xf8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e6a1
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x145f0
movl $0xf, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rbx)
cmpb $0x1, 0x78(%r14)
jne 0x5e71e
movl $0x90, %eax
leaq (%rbx,%rax), %rcx
movq %rcx, 0x80(%rbx)
movq 0x80(%r14), %rdx
addq %r14, %rax
cmpq %rax, %rdx
je 0x5e6ec
movq %rdx, 0x80(%rbx)
movq (%rax), %rcx
movq %rcx, 0x90(%rbx)
jmp 0x5e6f2
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x88(%r14), %rcx
movq %rcx, 0x88(%rbx)
movq %rax, 0x80(%r14)
movq $0x0, 0x88(%r14)
movb $0x0, 0x90(%r14)
movb $0x1, 0x78(%rbx)
movb $0x0, 0xa0(%rbx)
cmpb $0x1, 0xa0(%r14)
jne 0x5e796
movl $0xb8, %eax
leaq (%rbx,%rax), %rcx
movq %rcx, 0xa8(%rbx)
movq 0xa8(%r14), %rdx
addq %r14, %rax
cmpq %rax, %rdx
je 0x5e761
movq %rdx, 0xa8(%rbx)
movq (%rax), %rcx
movq %rcx, 0xb8(%rbx)
jmp 0x5e767
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0xb0(%r14), %rcx
movq %rcx, 0xb0(%rbx)
movq %rax, 0xa8(%r14)
movq $0x0, 0xb0(%r14)
movb $0x0, 0xb8(%r14)
movb $0x1, 0xa0(%rbx)
movq %rbx, %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpb $0x1, (%rsp)
jne 0x5e7fb
movq %rsp, %rdi
callq 0x14eb7
jmp 0x5e7fb
movq %rax, %rbx
cmpb $0x1, 0xe0(%rsp)
jne 0x5e805
leaq 0xf8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e805
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x5e805
movq %rax, %rbx
movq %rsp, %rdi
callq 0x60d2c
jmp 0x5e7fb
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x60e36
movq %rbx, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(boost::variant<ear::PolarSpeakerPosition, ear::CartesianSpeakerPosition> const&)
|
SpeakerPosition GainCalculatorDirectSpeakersImpl::_applyScreenEdgeLock(
const SpeakerPosition& position) {
return boost::apply_visitor(
[this](const auto& p) {
return SpeakerPosition(_applyScreenEdgeLock(p));
},
position);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
movl (%rdx), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
cmpl $0x13, %eax
ja 0x5eaa0
movq %rdx, %r15
movq %rsi, %r14
leaq 0x8(%rdx), %rsi
leaq 0x777fe(%rip), %rcx # 0xd6040
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rax)
cmpb $0x1, 0x80(%r15)
jne 0x5e89a
leaq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x88(%r15), %rsi
movq 0x90(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, -0x18(%r12)
movb $0x0, 0xa8(%rsp)
cmpb $0x1, 0xa8(%r15)
jne 0x5e8de
leaq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xb0(%r15), %rsi
movq 0xb8(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0xa8(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x5e24a
leaq 0x8(%rbx), %rdi
leaq 0xd0(%rsp), %r14
movq %r14, %rsi
callq 0x611ac
jmp 0x5e9c8
leaq 0x8(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rax)
cmpb $0x1, 0x80(%r15)
jne 0x5e95b
leaq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x88(%r15), %rsi
movq 0x90(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, -0x18(%r12)
movb $0x0, 0xa8(%rsp)
cmpb $0x1, 0xa8(%r15)
jne 0x5e99f
leaq 0xb0(%rsp), %rdi
leaq 0xc0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xb0(%r15), %rsi
movq 0xb8(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0xa8(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x5e492
leaq 0x8(%rbx), %rdi
leaq 0xd0(%rsp), %r14
movq %r14, %rsi
callq 0x612a0
movl %eax, (%rbx)
cmpb $0x1, 0xa0(%r14)
jne 0x5e9fd
leaq 0x188(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e9f5
movq 0x188(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x170(%rsp)
cmpb $0x1, 0x148(%rsp)
jne 0x5ea30
leaq 0x160(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5ea28
movq 0x160(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x148(%rsp)
cmpb $0x1, 0xa8(%rsp)
jne 0x5ea63
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5ea5b
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0xa8(%rsp)
cmpb $0x1, 0x80(%rsp)
jne 0x5ea8e
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5ea8e
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rax
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x61397
jmp 0x5eaaa
movq %rax, %rbx
cmpb $0x1, 0x80(%rsp)
jne 0x5eaf6
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5eaf6
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x5eaf6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x60ee6
jmp 0x5eaf6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x60e36
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::GainCalculatorDirectSpeakersImpl::_isLfeChannel(ear::DirectSpeakersTypeMetadata const&, std::function<void (ear::Warning const&)> const&)
|
bool GainCalculatorDirectSpeakersImpl::_isLfeChannel(
const DirectSpeakersTypeMetadata& metadata, const WarningCB& warning_cb) {
bool has_lfe_freq = (metadata.channelFrequency.lowPass != boost::none &&
metadata.channelFrequency.lowPass.get() <= 200 &&
metadata.channelFrequency.highPass == boost::none);
if (!has_lfe_freq && (metadata.channelFrequency.lowPass ||
metadata.channelFrequency.highPass))
warning_cb({Warning::Code::FREQ_NOT_LFE,
"frequency indication present but does "
"not indicate an LFE channel"});
bool has_lfe_name = false;
for (auto speakerLabel : metadata.speakerLabels) {
std::string nominalLabel = _nominalSpeakerLabel(speakerLabel);
if (nominalLabel == std::string("LFE1") ||
nominalLabel == std::string("LFE2")) {
has_lfe_name = true;
}
}
if (has_lfe_freq != has_lfe_name && metadata.speakerLabels.size())
warning_cb({Warning::Code::FREQ_SPEAKERLABEL_LFE_MISMATCH,
"LFE indication from frequency element does not match "
"speakerLabel"});
return has_lfe_freq || has_lfe_name;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, 0x90(%rsp)
cmpb $0x1, 0xe8(%rsi)
jne 0x5eb65
movsd 0x77602(%rip), %xmm0 # 0xd6130
ucomisd 0xf0(%r12), %xmm0
jb 0x5eb70
testb $0x1, 0xf8(%r12)
jne 0x5eb70
movq (%r12), %rbp
movq 0x8(%r12), %rcx
movb $0x1, %al
movq %rcx, 0x38(%rsp)
cmpq %rcx, %rbp
jne 0x5ebe4
xorl %ebx, %ebx
jmp 0x5ed92
cmpb $0x1, 0xf8(%r12)
jne 0x5ebc6
leaq 0x10(%rsp), %rdi
movl $0x2, -0x8(%rdi)
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x77760(%rip), %rsi # 0xd62ec
leaq 0x7779a(%rip), %rdx # 0xd632d
callq 0x37fd8
cmpq $0x0, 0x10(%r15)
je 0x5ee09
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq *0x18(%r15)
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x5ebc6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x145f0
movq (%r12), %rbp
movq 0x8(%r12), %rcx
xorl %eax, %eax
movl $0x0, %ebx
movq %rcx, 0x38(%rsp)
cmpq %rcx, %rbp
je 0x5edf3
movl %eax, 0x34(%rsp)
movq %r12, 0x80(%rsp)
movq %r15, 0x88(%rsp)
leaq 0x18(%rsp), %r13
leaq 0x70(%rsp), %r14
xorl %ebx, %ebx
leaq 0x8(%rsp), %r12
movq %r13, 0x8(%rsp)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x36894
leaq 0x40(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq %r12, %rdx
callq 0x5ee94
movq %r14, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x51203(%rip), %rsi # 0xafe4a
leaq 0x51200(%rip), %rdx # 0xafe4e
callq 0x37fd8
movq 0x48(%rsp), %rdx
cmpq 0x68(%rsp), %rdx
jne 0x5ec85
movb $0x1, %r15b
movq 0x60(%rsp), %r13
testq %rdx, %rdx
je 0x5ed16
movq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0x14640
testl %eax, %eax
je 0x5ed16
leaq 0xa8(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x51212(%rip), %rsi # 0xafeb6
leaq 0x5120f(%rip), %rdx # 0xafeba
callq 0x37fd8
movq 0x48(%rsp), %rdx
cmpq 0xa0(%rsp), %rdx
jne 0x5ece1
movq 0x98(%rsp), %r13
testq %rdx, %rdx
je 0x5ecee
movq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0x14640
testl %eax, %eax
sete %r15b
jmp 0x5ecf1
movq 0x98(%rsp), %r13
xorl %r15d, %r15d
jmp 0x5ecf1
movb $0x1, %r15b
leaq 0xa8(%rsp), %rax
cmpq %rax, %r13
je 0x5ed11
movq 0xa8(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x145f0
movq 0x60(%rsp), %r13
cmpq %r14, %r13
je 0x5ed2b
movq 0x70(%rsp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x145f0
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x5ed47
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %r13
cmpq %r13, %rdi
je 0x5ed63
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
orb %r15b, %bl
addq $0x20, %rbp
cmpq 0x38(%rsp), %rbp
jne 0x5ec09
movl 0x34(%rsp), %eax
movl %eax, %ecx
xorb %bl, %cl
testb $0x1, %cl
movq 0x88(%rsp), %r15
movq 0x80(%rsp), %r12
je 0x5edf3
movq 0x8(%r12), %rcx
cmpq (%r12), %rcx
je 0x5edf3
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
movl $0x1, -0x8(%rdi)
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x77573(%rip), %rsi # 0xd632e
leaq 0x775ad(%rip), %rdx # 0xd636f
callq 0x37fd8
cmpq $0x0, 0x10(%r15)
je 0x5ee0e
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq *0x18(%r15)
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x5edf1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x145f0
movl %ebp, %eax
orb %bl, %al
andb $0x1, %al
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x14200
callq 0x14200
jmp 0x5ee15
movq %rax, %rbx
jmp 0x5ee8c
jmp 0x5ee1c
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x5ee8c
movq 0x20(%rsp), %rsi
jmp 0x5ee84
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r14, %rdi
je 0x5ee54
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x5ee54
movq %rax, %rbx
jmp 0x5ee70
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x5ee70
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5ee8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %rbx, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::GainCalculatorDirectSpeakersImpl::_nominalSpeakerLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
std::string GainCalculatorDirectSpeakersImpl::_nominalSpeakerLabel(
const std::string& label) {
std::string ret = label;
std::smatch idMatch;
if (std::regex_search(label, idMatch, SPEAKER_URN_REGEX)) {
ret = idMatch[1].str();
}
if (_substitutions.count(label)) {
ret = _substitutions.at(label);
}
return ret;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x36894
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x160(%r15), %rcx
movq (%r14), %rdi
movq 0x8(%r14), %rsi
addq %rdi, %rsi
xorl %r8d, %r8d
callq 0x6ca52
testb %al, %al
je 0x5ef89
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
je 0x5ef21
movq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rsi
addq $-0x5, %rsi
cmpq $-0x3, %rsi
ja 0x5ef21
addq $0x18, %rax
jmp 0x5ef28
addq %rcx, %rax
addq $-0x48, %rax
cmpb $0x1, 0x10(%rax)
jne 0x5ef4a
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x20(%rsp), %rdi
callq 0x6ea9c
jmp 0x5ef5e
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x14760
movq (%r12), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5ef89
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x145f0
leaq 0x130(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x6eb16
addq $0x138, %r15 # imm = 0x138
cmpq %r15, %rax
je 0x5efbd
movq %r12, %rdi
movq %r14, %rsi
callq 0x60e92
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14320
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5efd3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5efe6
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5efff
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x145f0
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x5f013
movq (%r13), %rsi
incq %rsi
callq 0x145f0
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::GainCalculatorDirectSpeakersImpl::_findCandidates(ear::PolarSpeakerPosition const&, bool, double)
|
std::vector<std::pair<int, double>>
GainCalculatorDirectSpeakersImpl::_findCandidates(
const PolarSpeakerPosition& pos, bool isLfe, double tol) {
Eigen::RowVector3d cartPosition = toCartesianVector3d(pos);
std::vector<std::pair<int, double>> candidates;
double azMin = boost::get_optional_value_or(pos.azimuthMin, pos.azimuth);
double azMax = boost::get_optional_value_or(pos.azimuthMax, pos.azimuth);
double elMin =
boost::get_optional_value_or(pos.elevationMin, pos.elevation);
double elMax =
boost::get_optional_value_or(pos.elevationMax, pos.elevation);
double distMin =
boost::get_optional_value_or(pos.distanceMin, pos.distance);
double distMax =
boost::get_optional_value_or(pos.distanceMax, pos.distance);
for (int i = 0; i < _nChannels; ++i) {
Channel channel = _layout.channels()[i];
if (isLfe == _isLfe[i]) {
if ((insideAngleRange(_azimuths(i), azMin, azMax, tol) ||
std::abs(_elevations(i)) >= 90.0 - tol) &&
(_elevations(i) > elMin - tol) && (_elevations(i) < elMax + tol) &&
(_distances(i) > distMin - tol) &&
(_distances(i) < distMax + tol)) {
double distance = (_positions.row(i) - cartPosition).norm();
candidates.push_back(std::make_pair(i, distance));
}
}
}
return candidates;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movsd %xmm0, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
leaq 0x120(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rax)
cmpb $0x1, 0x78(%rdx)
jne 0x5f08e
leaq 0x1a0(%rsp), %rdi
leaq 0x1b0(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x80(%r15), %rsi
movq 0x88(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, -0x18(%rbx)
movb $0x0, 0x1c0(%rsp)
cmpb $0x1, 0xa0(%r15)
jne 0x5f0d2
leaq 0x1c8(%rsp), %rdi
leaq 0x1d8(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xa8(%r15), %rsi
movq 0xb0(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0x1c0(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x4db86
movaps 0x60(%rsp), %xmm0
movaps %xmm0, 0xf0(%rsp)
movaps %xmm0, 0x100(%rsp)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
cmpb $0x1, 0x1c0(%rsp)
jne 0x5f13b
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f133
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x1c0(%rsp)
cmpb $0x1, 0x198(%rsp)
jne 0x5f16e
leaq 0x1b0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f166
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x198(%rsp)
xorpd %xmm0, %xmm0
movupd %xmm0, (%r13)
movq $0x0, 0x10(%r13)
cmpl $0x0, 0xb8(%r14)
jle 0x5f54b
movsd 0x50(%r15), %xmm0
cmpb $0x0, 0x68(%r15)
jne 0x5f1a2
movsd %xmm0, (%rsp)
jmp 0x5f1ad
movsd 0x70(%r15), %xmm1
movsd %xmm1, (%rsp)
movzbl 0x8(%r15), %eax
movzbl 0x18(%r15), %ecx
cmpb $0x0, 0x58(%r15)
je 0x5f1c4
movsd 0x60(%r15), %xmm0
shll $0x4, %eax
shll $0x5, %ecx
cmpb $0x0, 0x40(%r15)
movsd 0x28(%r15), %xmm2
jne 0x5f1dd
movapd %xmm2, %xmm1
jmp 0x5f1e7
movapd %xmm2, %xmm1
movsd 0x48(%r15), %xmm2
movsd %xmm2, 0x8(%rsp)
cmpb $0x0, 0x30(%r15)
movsd %xmm0, 0x10(%rsp)
je 0x5f200
movsd 0x38(%r15), %xmm1
movsd (%r15,%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd (%r15,%rcx), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x508b0(%rip), %xmm2 # 0xafad0
movsd 0x28(%rsp), %xmm0
subsd %xmm0, %xmm2
movsd %xmm2, 0x30(%rsp)
subsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rsp)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
movq %r13, 0x18(%rsp)
movq %r14, %rdi
callq 0x45100
leaq 0x70(%rsp), %r13
movq (%rax), %r15
leaq (%rbx,%rbx,8), %rbp
shlq $0x4, %rbp
movq %r13, 0x60(%rsp)
movq (%r15,%rbp), %rsi
movq 0x8(%r15,%rbp), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x36894
addq %rbp, %r15
movq 0x30(%r15), %rax
movq %rax, 0x20(%r13)
movupd 0x20(%r15), %xmm0
movupd %xmm0, 0x10(%r13)
movb $0x0, 0x98(%rsp)
cmpb $0x1, 0x38(%r15)
jne 0x5f2e7
movq 0x50(%r15), %rax
movq %rax, 0x40(%r13)
movupd 0x40(%r15), %xmm0
movupd %xmm0, 0x30(%r13)
movb $0x1, 0x98(%rsp)
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x58(%r15)
jne 0x5f30a
movupd 0x60(%r15), %xmm0
movupd %xmm0, 0x50(%r13)
movb $0x1, 0xb8(%rsp)
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0x70(%r15)
movq 0x18(%rsp), %r13
jne 0x5f336
movupd 0x78(%r15), %xmm0
leaq 0x70(%rsp), %rax
movupd %xmm0, 0x68(%rax)
movb $0x1, 0xd0(%rsp)
movb 0x88(%r15), %al
movb %al, 0xe8(%rsp)
cmpq %rbx, 0x128(%r14)
jle 0x5f57f
movq 0x120(%r14), %rax
movl 0x24(%rsp), %ecx
cmpb %cl, (%rax,%rbx)
jne 0x5f4e2
cmpq %rbx, 0xe0(%r14)
jle 0x5f560
movq 0xd8(%r14), %rax
movsd (%rax,%rbx,8), %xmm0
movsd 0x48(%rsp), %xmm1
movsd 0x40(%rsp), %xmm2
movsd 0x28(%rsp), %xmm3
callq 0x4d458
movq 0xf0(%r14), %rcx
testb %al, %al
jne 0x5f3c9
cmpq %rbx, %rcx
jle 0x5f560
movq 0xe8(%r14), %rax
movsd (%rax,%rbx,8), %xmm0
andpd 0x4fca3(%rip), %xmm0 # 0xaf060
ucomisd 0x30(%rsp), %xmm0
jb 0x5f4e2
cmpq %rbx, %rcx
jle 0x5f560
movq 0xe8(%r14), %rax
movsd (%rax,%rbx,8), %xmm0
ucomisd 0x38(%rsp), %xmm0
jbe 0x5f4e2
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5f4e2
cmpq %rbx, 0x100(%r14)
jle 0x5f560
movq 0xf8(%r14), %rax
movsd (%rax,%rbx,8), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x5f4e2
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x5f4e2
movq 0x108(%r14), %rdx
movq 0x118(%r14), %rcx
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
setns %sil
orb %al, %sil
je 0x5f59e
movq 0x110(%r14), %rax
cmpq %rbx, %rax
jle 0x5f5bd
cmpq $0x3, %rcx
jne 0x5f5dc
movsd (%rdx,%rbx,8), %xmm0
subsd 0xf0(%rsp), %xmm0
mulsd %xmm0, %xmm0
leaq (%r12,%rax,8), %rcx
shlq $0x3, %rax
addq %rdx, %rcx
xorl %edx, %edx
movsd (%rcx), %xmm1
subsd 0x108(%rsp,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
addq %rax, %rcx
cmpq $0x2, %rdx
jne 0x5f48b
sqrtsd %xmm0, %xmm0
movl %ebx, 0x50(%rsp)
movsd %xmm0, 0x58(%rsp)
movq 0x8(%r13), %rsi
cmpq 0x10(%r13), %rsi
je 0x5f4d5
movupd 0x50(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%r13)
jmp 0x5f4e2
movq %r13, %rdi
leaq 0x50(%rsp), %rdx
callq 0x6ebe4
cmpb $0x1, 0xd0(%rsp)
jne 0x5f4f4
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x5f506
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x5f518
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x5f534
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
incq %rbx
movslq 0xb8(%r14), %rax
addq $0x8, %r12
cmpq %rax, %rbx
jl 0x5f272
movq %r13, %rax
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5420c(%rip), %rdi # 0xb3773
leaq 0x54222(%rip), %rsi # 0xb3790
leaq 0x551d2(%rip), %rcx # 0xb4747
movl $0x1ab, %edx # imm = 0x1AB
callq 0x143c0
leaq 0x541ed(%rip), %rdi # 0xb3773
leaq 0x54203(%rip), %rsi # 0xb3790
leaq 0x7791b(%rip), %rcx # 0xd6eaf
movl $0x19a, %edx # imm = 0x19A
callq 0x143c0
leaq 0x51d34(%rip), %rdi # 0xb12d9
leaq 0x51dd7(%rip), %rsi # 0xb1383
leaq 0x532cc(%rip), %rcx # 0xb287f
movl $0xb2, %edx
callq 0x143c0
leaq 0x51b56(%rip), %rdi # 0xb111a
leaq 0x51bf6(%rip), %rsi # 0xb11c1
leaq 0x57178(%rip), %rcx # 0xb674a
movl $0x7a, %edx
callq 0x143c0
leaq 0x51ebe(%rip), %rdi # 0xb14a1
leaq 0x51ef0(%rip), %rsi # 0xb14da
leaq 0x7793f(%rip), %rcx # 0xd6f30
movl $0x74, %edx
callq 0x143c0
movq %rax, %r14
cmpb $0x1, 0x198(%rsp)
jne 0x5f6bd
leaq 0x1b0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f6bd
movq 0x1b0(%rsp), %rsi
incq %rsi
jmp 0x5f6b8
jmp 0x5f645
movq %rax, %r14
leaq 0x120(%rsp), %rdi
callq 0x60ee6
jmp 0x5f6bd
movq %rax, %r14
cmpb $0x1, 0xd0(%rsp)
jne 0x5f65a
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x5f66c
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x5f67e
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x5f69f
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x5f69f
movq %rax, %r14
movq 0x18(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5f6bd
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x145f0
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::GainCalculatorDirectSpeakersImpl::_findCandidates(ear::CartesianSpeakerPosition const&, bool, double)
|
std::vector<std::pair<int, double>>
GainCalculatorDirectSpeakersImpl::_findCandidates(
const CartesianSpeakerPosition& pos, bool isLfe, double tol) {
Eigen::RowVector3d cartPosition = toCartesianVector3d(pos);
std::vector<std::pair<int, double>> candidates;
double XMin = boost::get_optional_value_or(pos.XMin, pos.X);
double XMax = boost::get_optional_value_or(pos.XMax, pos.X);
double YMin = boost::get_optional_value_or(pos.YMin, pos.Y);
double YMax = boost::get_optional_value_or(pos.YMax, pos.Y);
double ZMin = boost::get_optional_value_or(pos.ZMin, pos.Z);
double ZMax = boost::get_optional_value_or(pos.ZMax, pos.Z);
for (int i = 0; i < _nChannels; ++i) {
Channel channel = _layout.channels()[i];
if (isLfe == _isLfe[i]) {
if (_positions.row(i)(0) + tol >= XMin &&
_positions.row(i)(0) - tol <= XMax &&
_positions.row(i)(1) + tol >= YMin &&
_positions.row(i)(1) - tol <= YMax &&
_positions.row(i)(2) + tol >= ZMin &&
_positions.row(i)(2) - tol <= ZMax) {
double distance = (_positions.row(i) - cartPosition).norm();
candidates.push_back(std::make_pair(i, distance));
}
}
}
return candidates;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movsd %xmm0, 0x8(%rsp)
movl %ecx, 0x1c(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbp
leaq 0x120(%rsp), %rax
movl $0xf, %ecx
movq %rax, %rdi
movq %rdx, %rsi
rep movsq (%rsi), %es:(%rdi)
movb $0x0, 0x78(%rax)
cmpb $0x1, 0x78(%rdx)
jne 0x5f738
leaq 0x1a0(%rsp), %rdi
leaq 0x1b0(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x80(%r15), %rsi
movq 0x88(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, -0x18(%rbx)
movb $0x0, 0x1c0(%rsp)
cmpb $0x1, 0xa0(%r15)
jne 0x5f77c
leaq 0x1c8(%rsp), %rdi
leaq 0x1d8(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xa8(%r15), %rsi
movq 0xb0(%r15), %rdx
addq %rsi, %rdx
callq 0x36894
movb $0x1, 0x1c0(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x4db66
movaps 0x60(%rsp), %xmm0
movaps %xmm0, 0xf0(%rsp)
movaps %xmm0, 0x100(%rsp)
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x110(%rsp)
cmpb $0x1, 0x1c0(%rsp)
jne 0x5f7e5
leaq 0x1d8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f7dd
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x1c0(%rsp)
cmpb $0x1, 0x198(%rsp)
jne 0x5f818
leaq 0x1b0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f810
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x198(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
movsd 0x28(%r15), %xmm0
cmpb $0x0, 0x30(%r15)
movsd %xmm0, 0x30(%rsp)
je 0x5f840
movsd 0x38(%r15), %xmm0
movsd %xmm0, 0x38(%rsp)
cmpb $0x0, 0x40(%r15)
je 0x5f859
movsd 0x48(%r15), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x50(%r15), %xmm0
cmpb $0x0, 0x58(%r15)
movsd %xmm0, 0x20(%rsp)
je 0x5f872
movsd 0x60(%r15), %xmm0
movsd %xmm0, 0x28(%rsp)
cmpb $0x0, 0x68(%r15)
je 0x5f88b
movsd 0x70(%r15), %xmm0
movsd %xmm0, 0x20(%rsp)
cmpl $0x0, 0xb8(%r14)
jle 0x5fba8
movzbl 0x8(%r15), %eax
movzbl 0x18(%r15), %ecx
shll $0x4, %eax
shll $0x5, %ecx
movsd (%r15,%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movsd (%r15,%rcx), %xmm0
movsd %xmm0, 0x40(%rsp)
xorl %r12d, %r12d
xorl %ebx, %ebx
movq %rbp, 0x10(%rsp)
movq %r14, %r13
movq %r14, %rdi
callq 0x45100
leaq 0x70(%rsp), %r14
movq (%rax), %r15
leaq (%rbx,%rbx,8), %rbp
shlq $0x4, %rbp
movq %r14, 0x60(%rsp)
movq (%r15,%rbp), %rsi
movq 0x8(%r15,%rbp), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x36894
addq %rbp, %r15
movq 0x30(%r15), %rax
movq %rax, 0x20(%r14)
movupd 0x20(%r15), %xmm0
movupd %xmm0, 0x10(%r14)
movb $0x0, 0x98(%rsp)
cmpb $0x1, 0x38(%r15)
jne 0x5f943
movq 0x50(%r15), %rax
movq %rax, 0x40(%r14)
movupd 0x40(%r15), %xmm0
movupd %xmm0, 0x30(%r14)
movb $0x1, 0x98(%rsp)
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x58(%r15)
jne 0x5f966
movupd 0x60(%r15), %xmm0
movupd %xmm0, 0x50(%r14)
movb $0x1, 0xb8(%rsp)
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0x70(%r15)
movq 0x10(%rsp), %rbp
jne 0x5f996
movupd 0x78(%r15), %xmm0
leaq 0x70(%rsp), %rax
movupd %xmm0, 0x68(%rax)
movb $0x1, 0xd0(%rsp)
movb $0x1, %al
jmp 0x5f998
xorl %eax, %eax
movq %r13, %r14
movb 0x88(%r15), %cl
movb %cl, 0xe8(%rsp)
cmpq %rbx, 0x128(%r13)
jle 0x5fbbd
movq 0x120(%r14), %rcx
movl 0x1c(%rsp), %edx
cmpb %dl, (%rcx,%rbx)
jne 0x5fb45
movq 0x108(%r14), %rcx
movq 0x118(%r14), %rsi
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
setns %dil
orb %dl, %dil
je 0x5fc1a
movq 0x110(%r14), %rdx
cmpq %rbx, %rdx
jle 0x5fbfb
testq %rsi, %rsi
jle 0x5fbdc
leaq (%rcx,%rbx,8), %rdi
movsd (%rdi), %xmm0
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm2
addsd %xmm2, %xmm1
ucomisd 0x48(%rsp), %xmm1
jb 0x5fb45
movapd %xmm0, %xmm1
subsd %xmm2, %xmm1
movsd 0x40(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jb 0x5fb45
cmpq $0x1, %rsi
je 0x5fbdc
movsd (%rdi,%rdx,8), %xmm1
movapd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm3
addsd %xmm3, %xmm2
ucomisd 0x38(%rsp), %xmm2
jb 0x5fb45
subsd %xmm3, %xmm1
movsd 0x30(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jb 0x5fb45
cmpq $0x2, %rsi
jbe 0x5fbdc
movq %rdx, %r8
shlq $0x4, %r8
movsd (%rdi,%r8), %xmm1
movapd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm3
addsd %xmm3, %xmm2
ucomisd 0x28(%rsp), %xmm2
jb 0x5fb45
subsd %xmm3, %xmm1
movsd 0x20(%rsp), %xmm2
ucomisd %xmm1, %xmm2
jb 0x5fb45
cmpq $0x3, %rsi
jne 0x5fc39
subsd 0xf0(%rsp), %xmm0
mulsd %xmm0, %xmm0
leaq (%r12,%rdx,8), %rax
shlq $0x3, %rdx
addq %rax, %rcx
xorl %eax, %eax
movsd (%rcx), %xmm1
subsd 0x108(%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
addq %rdx, %rcx
cmpq $0x2, %rax
jne 0x5fae7
sqrtsd %xmm0, %xmm0
movl %ebx, 0x50(%rsp)
movsd %xmm0, 0x58(%rsp)
movq 0x8(%rbp), %rsi
cmpq 0x10(%rbp), %rsi
je 0x5fb31
movupd 0x50(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x10, 0x8(%rbp)
jmp 0x5fb3e
movq %rbp, %rdi
leaq 0x50(%rsp), %rdx
callq 0x6ebe4
movb 0xd0(%rsp), %al
testb $0x1, %al
je 0x5fb51
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x5fb63
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x5fb75
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x5fb91
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
incq %rbx
movslq 0xb8(%r14), %rax
addq $0x8, %r12
cmpq %rax, %rbx
jl 0x5f8cb
movq %rbp, %rax
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53baf(%rip), %rdi # 0xb3773
leaq 0x53bc5(%rip), %rsi # 0xb3790
leaq 0x772dd(%rip), %rcx # 0xd6eaf
movl $0x19a, %edx # imm = 0x19A
callq 0x143c0
leaq 0x53b90(%rip), %rdi # 0xb3773
leaq 0x53ba6(%rip), %rsi # 0xb3790
leaq 0x774b7(%rip), %rcx # 0xd70a8
movl $0x1ab, %edx # imm = 0x1AB
callq 0x143c0
leaq 0x51518(%rip), %rdi # 0xb111a
leaq 0x515b8(%rip), %rsi # 0xb11c1
leaq 0x56b3a(%rip), %rcx # 0xb674a
movl $0x7a, %edx
callq 0x143c0
leaq 0x516b8(%rip), %rdi # 0xb12d9
leaq 0x5175b(%rip), %rsi # 0xb1383
leaq 0x52c50(%rip), %rcx # 0xb287f
movl $0xb2, %edx
callq 0x143c0
leaq 0x51861(%rip), %rdi # 0xb14a1
leaq 0x51893(%rip), %rsi # 0xb14da
leaq 0x772e2(%rip), %rcx # 0xd6f30
movl $0x74, %edx
callq 0x143c0
movq %rax, %r14
cmpb $0x0, 0xd0(%rsp)
je 0x5fc6d
movb $0x0, 0xd0(%rsp)
cmpb $0x1, 0xb8(%rsp)
jne 0x5fc7f
movb $0x0, 0xb8(%rsp)
cmpb $0x1, 0x98(%rsp)
jne 0x5fc91
movb $0x0, 0x98(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x5fcef
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x5fcef
movq %rax, %r14
cmpb $0x1, 0x198(%rsp)
jne 0x5fd0d
leaq 0x1b0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fd0d
movq 0x1b0(%rsp), %rsi
incq %rsi
jmp 0x5fd08
movq %rax, %r14
leaq 0x120(%rsp), %rdi
callq 0x60e36
jmp 0x5fd0d
movq %rax, %r14
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5fd0d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x145f0
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::GainCalculatorDirectSpeakersImpl::_findChannelWithinBounds(boost::variant<ear::PolarSpeakerPosition, ear::CartesianSpeakerPosition> const&, bool, double)
|
boost::optional<int>
GainCalculatorDirectSpeakersImpl::_findChannelWithinBounds(
const SpeakerPosition& position, bool isLfe, double tol) {
std::vector<std::pair<int, double>> candidates =
_findCandidates(position, isLfe, tol);
if (candidates.size() == 0) {
return boost::none;
} else if (candidates.size() == 1) {
return candidates[0].first;
} else {
std::sort(candidates.begin(), candidates.end(),
[](const std::pair<int, double>& a,
const std::pair<int, double>& b) -> bool {
return a.second < b.second;
});
if (std::abs(candidates[0].second - candidates[1].second) > tol) {
return candidates[0].first;
}
}
return boost::none;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movsd %xmm0, (%rsp)
callq 0x5fd16
movq (%r14), %rbx
movq 0x8(%r14), %r14
movq %r14, %r15
subq %rbx, %r15
movq %r15, %rax
sarq $0x4, %rax
je 0x5fe3f
cmpq $0x1, %rax
je 0x5fe77
cmpq %r14, %rbx
je 0x5fe59
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x60696
cmpq $0x101, %r15 # imm = 0x101
jl 0x5fe4e
leaq 0x100(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6099c
cmpq %r14, %r15
je 0x5fe59
addq $0x108, %rbx # imm = 0x108
movl (%r15), %eax
movsd 0x8(%r15), %xmm0
movsd -0x8(%r15), %xmm1
ucomisd %xmm0, %xmm1
movq %r15, %rcx
jbe 0x5fe29
movq %rbx, %rcx
movl -0x18(%rcx), %edx
movl %edx, -0x8(%rcx)
movsd %xmm1, (%rcx)
movsd -0x20(%rcx), %xmm1
addq $-0x10, %rcx
ucomisd %xmm0, %xmm1
ja 0x5fe0c
addq $-0x8, %rcx
movl %eax, (%rcx)
movsd %xmm0, 0x8(%rcx)
addq $0x10, %r15
addq $0x10, %rbx
cmpq %r14, %r15
jne 0x5fdf1
jmp 0x5fe59
xorl %r14d, %r14d
movl $0x0, %eax
testq %rbx, %rbx
jne 0x5fe8a
jmp 0x5fe9d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6099c
movq 0x8(%rsp), %rbx
movsd 0x8(%rbx), %xmm0
subsd 0x18(%rbx), %xmm0
andpd 0x4f1f0(%rip), %xmm0 # 0xaf060
ucomisd (%rsp), %xmm0
jbe 0x5fe85
movl (%rbx), %eax
shlq $0x20, %rax
movl $0x1, %r14d
jmp 0x5fe8a
xorl %r14d, %r14d
xorl %eax, %eax
orq %rax, %r14
movq 0x18(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x145f0
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::GainCalculatorDirectSpeakersImpl::calculate(ear::DirectSpeakersTypeMetadata const&, ear::OutputGains&, std::function<void (ear::Warning const&)> const&)
|
void GainCalculatorDirectSpeakersImpl::calculate(
const DirectSpeakersTypeMetadata& metadata, OutputGains& direct,
const WarningCB& warning_cb) {
if (metadata.audioPackFormatID && metadata.speakerLabels.size() == 0)
throw adm_error(
"common definitions audioPackFormatID specified without any "
"speakerLabels as specified in the common definitions file");
direct.check_size(_nChannels);
boost::apply_visitor(throw_if_not_implemented(), metadata.position);
double tol = 1e-5;
bool isLfe = _isLfeChannel(metadata, warning_cb);
direct.zero();
if (metadata.audioPackFormatID) {
auto found_pack = itu_packs.find(metadata.audioPackFormatID.get());
if (found_pack != itu_packs.end()) {
const std::string& itu_layout_name = found_pack->second;
std::string label = _nominalSpeakerLabel(metadata.speakerLabels[0]);
for (const MappingRule& rule : rules) {
if (rule_applies(rule, itu_layout_name, label, _layout)) {
for (auto& channel_gain : rule.gains) {
auto idx = _layout.indexForName(channel_gain.first);
ear_assert((bool)idx, "mapping channel not found");
direct.write(idx.get(), channel_gain.second);
}
return;
}
}
}
}
// try to find a speaker that matches a speakerLabel and type; earlier
// speakerLabel values have higher priority
for (std::string speakerLabel : metadata.speakerLabels) {
std::string nominalLabel = _nominalSpeakerLabel(speakerLabel);
auto it =
std::find(_channelNames.begin(), _channelNames.end(), nominalLabel);
if (it != _channelNames.end()) {
int index = static_cast<int>(std::distance(_channelNames.begin(), it));
if (isLfe == _isLfe[index]) {
direct.write(index, 1.0);
return;
}
}
}
// shift the nominal speaker position to the screen edges if specified
SpeakerPosition shiftedPosition = _applyScreenEdgeLock(metadata.position);
// otherwise, find the closest speaker with the correct type within the
// given bounds
boost::optional<int> index =
_findChannelWithinBounds(shiftedPosition, isLfe, tol);
if (index) {
direct.write(boost::get(index), 1.0);
return;
}
// otherwise, use the point source panner for non-LFE, and handle LFE
// channels using downmixing rules
if (isLfe) {
auto it = std::find(_channelNames.begin(), _channelNames.end(), "LFE1");
if (it != _channelNames.end()) {
int index = static_cast<int>(std::distance(_channelNames.begin(), it));
direct.write(index, 1.0);
}
return;
} else {
Eigen::Vector3d pos = toCartesianVector3d(shiftedPosition);
Eigen::VectorXd gains = _pointSourcePanner->handle(pos).get();
mask_write(direct, !_isLfe, gains);
return;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0x108(%rsi)
jne 0x5fedd
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x604b8
movslq 0xb8(%r14), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movl 0x18(%r15), %ecx
movl %ecx, %eax
sarl $0x1f, %eax
xorl %ecx, %eax
jne 0x603a6
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5eafe
movb %al, 0x7(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
cmpb $0x1, 0x108(%r15)
movq %rbx, 0x30(%rsp)
movq %r15, %rcx
movq %r15, 0x28(%rsp)
jne 0x60101
leaq 0x110(%rcx), %rsi
leaq 0xb0cff(%rip), %r12 # 0x110c40
movq %r12, %rdi
callq 0x6eb16
movq 0x28(%rsp), %rcx
addq $0x8, %r12
movq %rax, 0x38(%rsp)
cmpq %r12, %rax
je 0x60101
movq (%rcx), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x5ee94
leaq 0xb0cb1(%rip), %rax # 0x110c28
movq (%rax), %rbx
movq 0x8(%rax), %rax
movb $0x1, %bpl
movq %rax, 0x58(%rsp)
cmpq %rax, %rbx
je 0x600d8
addq $0x40, 0x38(%rsp)
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
cmpq %rdi, %rsi
je 0x5ffb2
movq 0x38(%rsp), %rdx
callq 0x613d7
cmpq 0x40(%rbx), %rax
je 0x6002a
movq 0x58(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x60009
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
callq 0x450de
movq 0x50(%rbx), %rdi
movq 0x58(%rbx), %rsi
leaq 0x70(%rsp), %rdx
callq 0x613d7
movq %rax, %r12
movq 0x58(%rbx), %r15
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x60004
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x145f0
cmpq %r15, %r12
je 0x6002a
movq 0x10(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x6002a
testq %rdx, %rdx
je 0x6003e
movq (%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0x14640
testl %eax, %eax
je 0x6003e
addq $0x68, %rbx
cmpq 0x58(%rsp), %rbx
jne 0x5ff95
jmp 0x600d5
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %r15
cmpq %r15, %r12
je 0x600d1
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
callq 0x45524
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq %r12, %rdx
callq 0x613d7
movq %rax, %rbp
movq 0x78(%rsp), %r13
leaq 0x70(%rsp), %rdi
callq 0x37440
cmpq %r13, %rbp
movq 0x30(%rsp), %r13
je 0x6002a
addq $0x28, %r12
cmpq %r15, %r12
jne 0x6004f
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %rbx
cmpq %rbx, %r12
je 0x600d1
movq %r14, %rdi
movq %r12, %rsi
callq 0x459b6
testb $0x1, %al
je 0x603e1
sarq $0x20, %rax
movsd 0x20(%r12), %xmm0
movq (%r13), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
addq $0x28, %r12
jmp 0x6009b
xorl %ebp, %ebp
jmp 0x600d8
movb $0x1, %bpl
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x600f3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
movq 0x28(%rsp), %rcx
je 0x60394
movq (%rcx), %r15
movq 0x8(%rcx), %rbx
cmpq %rbx, %r15
je 0x601e2
leaq 0x80(%rsp), %rbp
leaq 0x70(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %rbp, 0x70(%rsp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x36894
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5ee94
movq 0xc0(%r14), %rdi
movq 0xc8(%r14), %rsi
movq %r13, %rdx
callq 0x5c0b0
cmpq 0xc8(%r14), %rax
je 0x6019f
subq 0xc0(%r14), %rax
shrq $0x5, %rax
movslq %eax, %rsi
testq %rsi, %rsi
js 0x603c2
cmpq %rsi, 0x128(%r14)
jle 0x603c2
movq 0x120(%r14), %rax
movb 0x7(%rsp), %cl
cmpb %cl, (%rax,%rsi)
je 0x6028f
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x601bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x601d5
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x145f0
addq $0x20, %r15
cmpq %rbx, %r15
jne 0x60123
movq 0x28(%rsp), %rdx
addq $0x18, %rdx
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5e80e
movzbl 0x7(%rsp), %edx
movsd 0x6d420(%rip), %xmm0 # 0xcd628
movq %r14, %rdi
movq %r12, %rsi
callq 0x5fd62
movq 0x30(%rsp), %rbx
testb $0x1, %al
je 0x60239
sarq $0x20, %rax
movq (%rbx), %rcx
movsd 0x4eddd(%rip), %xmm0 # 0xaf008
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
jmp 0x6038a
cmpb $0x0, 0x7(%rsp)
je 0x602e1
movq 0xc0(%r14), %rdi
movq 0xc8(%r14), %rsi
leaq 0x4fbf1(%rip), %rdx # 0xafe4a
callq 0x6ed23
cmpq 0xc8(%r14), %rax
je 0x6038a
subq 0xc0(%r14), %rax
shrq $0x5, %rax
movslq %eax, %rsi
movq (%rbx), %rax
movsd 0x4ed84(%rip), %xmm0 # 0xaf008
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x6038a
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movsd 0x4ed69(%rip), %xmm0 # 0xaf008
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x602be
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x60394
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x60394
leaq 0x158(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x60f42
leaq 0x8(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x4dc4e
leaq 0x158(%rsp), %rdi
callq 0x6c94c
movq 0x70(%r14), %rsi
movq 0x18(%rsp), %rax
leaq 0x140(%rsp), %rdx
movq %rax, 0x10(%rdx)
movups 0x8(%rsp), %xmm0
movaps %xmm0, (%rdx)
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
callq *(%rax)
cmpb $0x0, 0x40(%rsp)
je 0x60511
leaq 0x48(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x55e5e
cmpb $0x1, 0x40(%rsp)
jne 0x60364
movq 0x48(%rsp), %rdi
callq 0x14720
addq $0x120, %r14 # imm = 0x120
leaq 0x40(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x60(%rsp), %rdx
movq %rbx, %rdi
callq 0x60fab
movq 0x60(%rsp), %rdi
callq 0x14720
leaq 0x70(%rsp), %rdi
callq 0x6c94c
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
decl %eax
cmpl $0x12, %eax
ja 0x603bd
leaq 0x75d2c(%rip), %rcx # 0xd60e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x367ea
leaq 0x533aa(%rip), %rdi # 0xb3773
leaq 0x533c0(%rip), %rsi # 0xb3790
leaq 0x76ad8(%rip), %rcx # 0xd6eaf
movl $0x19a, %edx # imm = 0x19A
callq 0x143c0
movl $0x10, %edi
callq 0x14290
movq %rax, %r14
leaq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
movq %rax, (%rdi)
leaq 0x75fe0(%rip), %rsi # 0xd63e5
leaq 0x75ff2(%rip), %rdx # 0xd63fe
callq 0x37fd8
movb $0x1, %bl
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0x42fb0
xorl %ebx, %ebx
leaq 0xab25f(%rip), %rsi # 0x10b688
movq 0xafb48(%rip), %rdx # 0x10ff78
movq %r14, %rdi
callq 0x14a60
movl $0x10, %edi
callq 0x14290
movq %rax, %r14
leaq 0x80(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x8(%rsp), %rsi
movq $0x12, (%rsi)
leaq 0x70(%rsp), %rdi
xorl %edx, %edx
callq 0x14ae0
leaq 0x70(%rsp), %rsi
movq %rax, (%rsi)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rsi)
movups 0x4f4f5(%rip), %xmm0 # 0xaf976
movups %xmm0, (%rax)
movw $0x6e6f, 0x10(%rax) # imm = 0x6E6F
movq %rcx, 0x8(%rsi)
movq (%rsi), %rax
movb $0x0, (%rax,%rcx)
movb $0x1, %bpl
movq %r14, %rdi
callq 0x4aada
xorl %ebp, %ebp
leaq 0xaac87(%rip), %rsi # 0x10b130
movq 0xafac8(%rip), %rdx # 0x10ff78
movq %r14, %rdi
callq 0x14a60
movl $0x10, %edi
callq 0x14290
movq %rax, %r14
leaq 0x80(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x75e98(%rip), %rsi # 0xd6370
leaq 0x75f05(%rip), %rdx # 0xd63e4
leaq 0x70(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0x3b0fe
xorl %ebp, %ebp
leaq 0xaae56(%rip), %rsi # 0x10b358
movq 0xaf9df(%rip), %rdx # 0x10fee8
movq %r14, %rdi
callq 0x14a60
leaq 0x532e9(%rip), %rdi # 0xb3801
leaq 0x532f9(%rip), %rsi # 0xb3818
leaq 0x5331b(%rip), %rcx # 0xb3841
movl $0x4bc, %edx # imm = 0x4BC
callq 0x143c0
jmp 0x605db
movq %rax, %r15
movq 0x60(%rsp), %rdi
jmp 0x60552
movq %rax, %r15
cmpb $0x1, 0x40(%rsp)
jne 0x605de
movq 0x48(%rsp), %rdi
callq 0x14720
jmp 0x605de
jmp 0x605db
movq %rax, %r15
leaq 0x158(%rsp), %rdi
callq 0x6c94c
jmp 0x605de
jmp 0x605db
jmp 0x605db
jmp 0x60650
jmp 0x6057d
jmp 0x605a4
movq %rax, %r15
movq 0x70(%rsp), %rdi
cmpq %rbx, %rdi
je 0x6059a
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x605a7
jmp 0x6068e
movq %rax, %r15
movq %r14, %rdi
callq 0x14460
jmp 0x6068e
movq %rax, %r15
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x6063b
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x6063b
movq %rax, %r15
leaq 0x70(%rsp), %rdi
callq 0x6c94c
jmp 0x6068e
movq %rax, %r15
movq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x60612
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bl, %bl
jne 0x6061b
jmp 0x6063b
movq %rax, %r15
movq %r14, %rdi
callq 0x14460
jmp 0x6063b
jmp 0x60638
movq %rax, %r15
leaq 0x70(%rsp), %rdi
callq 0x37440
jmp 0x6063b
jmp 0x60638
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6068e
movq 0x18(%rsp), %rsi
jmp 0x60686
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x60674
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
jmp 0x60674
movq %rax, %r15
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6068e
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x145f0
movq %r15, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/direct_speakers/gain_calculator_direct_speakers.cpp
|
ear::ScreenEdgeLockHandler::handleAzimuthElevation(double, double, ear::ScreenEdgeLock)
|
std::pair<double, double> handleAzimuthElevation(
double azimuth, double elevation, ScreenEdgeLock screenEdgeLock) {
if (screenEdgeLock.horizontal || screenEdgeLock.vertical)
throw not_implemented("screenEdgeLock");
return std::make_pair(azimuth, elevation);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, (%rsi)
jne 0x60ca2
cmpb $0x1, 0x28(%rsi)
je 0x60ca2
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x75740(%rip), %rsi # 0xd63ff
leaq 0x75747(%rip), %rdx # 0xd640d
leaq 0x8(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4aada
xorl %ebp, %ebp
leaq 0xaa447(%rip), %rsi # 0x10b130
movq 0xaf288(%rip), %rdx # 0x10ff78
movq %rbx, %rdi
callq 0x14a60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x60d12
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x60d1c
jmp 0x60d24
movq %rax, %r14
movq %rbx, %rdi
callq 0x14460
movq %r14, %rdi
callq 0x14ad0
|
/ebu[P]libear/src/direct_speakers/../common/screen_edge_lock.hpp
|
ear::ScreenEdgeLock::~ScreenEdgeLock()
|
struct EAR_EXPORT ScreenEdgeLock {
/// `screenEdgeLock` attribute on `position` element with
/// `coordinate="azimuth"` or `coordinate="X"`
boost::optional<std::string> horizontal;
/// `screenEdgeLock` attribute on `position` element with
/// `coordinate="elevation"` or `coordinate="Z"`
boost::optional<std::string> vertical;
}
|
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x60d52
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x60d4e
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x28(%rbx)
cmpb $0x1, (%rbx)
jne 0x60d72
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x60d6f
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, (%rbx)
popq %rbx
retq
|
/ebu[P]libear/include/ear/metadata.hpp
|
ear::ScreenEdgeLockHandler::handleVector(Eigen::Matrix<double, 3, 1, 0, 3, 1>, ear::ScreenEdgeLock)
|
std::tuple<double, double, double> handleVector(
Eigen::Vector3d pos, ScreenEdgeLock screenEdgeLock) {
if (screenEdgeLock.horizontal || screenEdgeLock.vertical)
throw not_implemented("screenEdgeLock");
return std::make_tuple(pos(0), pos(1), pos(2));
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, (%rcx)
jne 0x60dab
cmpb $0x1, 0x28(%rcx)
je 0x60dab
movups 0x8(%rdx), %xmm0
shufps $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
movups %xmm0, (%rdi)
movsd (%rdx), %xmm0
movsd %xmm0, 0x10(%rdi)
movq %rdi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x14290
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x75637(%rip), %rsi # 0xd63ff
leaq 0x7563e(%rip), %rdx # 0xd640d
leaq 0x8(%rsp), %rdi
callq 0x37fd8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4aada
xorl %ebp, %ebp
leaq 0xaa33e(%rip), %rsi # 0x10b130
movq 0xaf17f(%rip), %rdx # 0x10ff78
movq %rbx, %rdi
callq 0x14a60
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x60e1b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x145f0
testb %bpl, %bpl
jne 0x60e25
jmp 0x60e2d
movq %rax, %r14
movq %rbx, %rdi
callq 0x14460
movq %r14, %rdi
callq 0x14ad0
nop
|
/ebu[P]libear/src/direct_speakers/../common/screen_edge_lock.hpp
|
ear::CartesianSpeakerPosition::~CartesianSpeakerPosition()
|
struct EAR_EXPORT CartesianSpeakerPosition {
CartesianSpeakerPosition(double X = 0.0, double Y = 1.0, double Z = 0.0)
: X(X), Y(Y), Z(Z){};
double X;
boost::optional<double> XMin;
boost::optional<double> XMax;
double Y;
boost::optional<double> YMin;
boost::optional<double> YMax;
double Z;
boost::optional<double> ZMin;
boost::optional<double> ZMax;
ScreenEdgeLock screenEdgeLock;
}
|
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0xa0(%rdi)
jne 0x60e68
movq 0xa8(%rbx), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x60e61
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0xa0(%rbx)
cmpb $0x1, 0x78(%rbx)
jne 0x60e90
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x60e8c
movq (%rax), %rsi
incq %rsi
callq 0x145f0
movb $0x0, 0x78(%rbx)
popq %rbx
retq
|
/ebu[P]libear/include/ear/metadata.hpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.