name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<6, 8, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
inline Vector<T, Size>::Vector (void)
{
for (int i = 0; i < Size; i++)
m_data[i] = T();
}
|
xorps %xmm0, %xmm0
leaq -0x58(%rsp), %rax
cmpl $0x2, %esi
jne 0x398026
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x663cc2(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x397feb
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x397fe0
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x397fde
movq 0x30(%rdi), %rax
movq %rax, -0x58(%rsp)
movq 0x40(%rdi), %rax
movq %rax, -0x50(%rsp)
movq 0x50(%rdi), %rax
movq %rax, -0x48(%rsp)
jmp 0x398063
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x6739b8(%rip), %rcx # 0xa0b9f0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x39803c
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0xc, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39803a
xorps %xmm0, %xmm0
leaq -0x38(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x663c20(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39808f
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0xc, %rsi
je 0x398084
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x398082
leaq -0x38(%rsp), %rax
leaq -0x58(%rsp), %rcx
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,8), %xmm0
movss %xmm0, (%rax,%rsi,4)
incq %rsi
cmpq $0x3, %rsi
jne 0x3980bd
leaq 0x1(%rdx), %rsi
addq $0xc, %rax
addq $0x4, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x3980bb
movl $0x0, -0x60(%rsp)
movq $0x0, -0x68(%rsp)
xorl %eax, %eax
movss -0x38(%rsp,%rax,4), %xmm0
addss -0x2c(%rsp,%rax,4), %xmm0
movss %xmm0, -0x68(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3980f7
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x70(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39813a
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<9, 8, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
inline Vector<T, Size>::Vector (void)
{
for (int i = 0; i < Size; i++)
m_data[i] = T();
}
|
xorps %xmm0, %xmm0
leaq -0x48(%rsp), %rax
cmpl $0x2, %esi
jne 0x3981be
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x663b2a(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x398183
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x398178
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x398176
movq 0x30(%rdi), %rax
movq %rax, -0x48(%rsp)
movq 0x40(%rdi), %rax
movq %rax, -0x40(%rsp)
movq 0x50(%rdi), %rax
movq %rax, -0x38(%rsp)
jmp 0x3981fb
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x673820(%rip), %rcx # 0xa0b9f0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x3981d4
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0xc, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x3981d2
movss -0x48(%rsp), %xmm0
movss -0x40(%rsp), %xmm1
addss -0x44(%rsp), %xmm0
addss -0x3c(%rsp), %xmm1
movss -0x38(%rsp), %xmm2
addss -0x34(%rsp), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x2c(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x398259
retq
nop
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<10, 8, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(negate(in0));
}
|
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %esi
jne 0x3982e8
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x663a00(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x3982ad
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x3982a2
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3982a0
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x20(%rsp)
jmp 0x398325
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x6736f6(%rip), %rcx # 0xa0b9f0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x3982fe
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0xc, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x3982fc
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x3a723c
movss (%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0x4(%r14), %xmm0
addss 0xc(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x4(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x28(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x30(%rsp)
movl $0x2, 0x38(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x28(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x398394
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<13, 8, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(in0) + reduceToVec3(increment(in0));
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x3987aa
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x66353e(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39876f
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x398764
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x398762
movq 0x30(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%rsp)
jmp 0x3987e7
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x673234(%rip), %rcx # 0xa0b9f0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x3987c0
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0xc, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x3987be
leaq 0x30(%rsp), %rsi
movss (%rsi), %xmm0
movss 0x8(%rsi), %xmm1
addss 0x4(%rsi), %xmm0
addss 0xc(%rsi), %xmm1
movss 0x10(%rsi), %xmm2
addss 0x14(%rsi), %xmm2
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x28(%rsp)
movss %xmm2, 0x2c(%rsp)
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3a72bd
movss (%r14), %xmm0
addss 0x4(%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0xc(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x18(%rsp)
movss %xmm1, 0x1c(%rsp)
movss %xmm2, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x24(%rsp,%rax,4), %xmm0
addss 0x18(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x398870
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x48(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x50(%rsp)
movl $0x2, 0x58(%rsp)
movl $0x2, %eax
movss (%rsp,%rax,4), %xmm0
movslq 0x48(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3988b3
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<14, 8, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(in0) + reduceToVec3(decrement(in0));
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x398948
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x6633a0(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39890d
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x398902
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x398900
movq 0x30(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%rsp)
jmp 0x398985
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x673096(%rip), %rcx # 0xa0b9f0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x39895e
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0xc, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39895c
leaq 0x30(%rsp), %rsi
movss (%rsi), %xmm0
movss 0x8(%rsi), %xmm1
addss 0x4(%rsi), %xmm0
addss 0xc(%rsi), %xmm1
movss 0x10(%rsi), %xmm2
addss 0x14(%rsi), %xmm2
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x28(%rsp)
movss %xmm2, 0x2c(%rsp)
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x3a7340
movss (%r14), %xmm0
addss 0x4(%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0xc(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x18(%rsp)
movss %xmm1, 0x1c(%rsp)
movss %xmm2, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x24(%rsp,%rax,4), %xmm0
addss 0x18(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x398a0e
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x48(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x50(%rsp)
movl $0x2, 0x58(%rsp)
movl $0x2, %eax
movss (%rsp,%rax,4), %xmm0
movslq 0x48(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x398a51
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<11, 9, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(increment(in0)) + reduceToVec3(increment(in0));
}
|
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
cmpl $0x2, %esi
jne 0x39902b
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x662ce2(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x398fcd
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x398fc2
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x398fc0
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x50(%rsp)
movss %xmm0, 0x58(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x5c(%rsp)
movss %xmm0, 0x64(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x68(%rsp)
movss %xmm0, 0x70(%rsp)
jmp 0x39906e
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x6729e0(%rip), %rcx # 0xa0ba20
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x399047
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x399042
leaq 0x9c(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3a744a
movl $0x0, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
xorl %eax, %eax
movss 0x9c(%rsp,%rax,4), %xmm0
addss 0xa8(%rsp,%rax,4), %xmm0
movss %xmm0, 0x78(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399096
movl $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
xorl %eax, %eax
movss 0x78(%rsp,%rax,4), %xmm0
addss 0xb4(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3990ca
leaq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3a744a
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x78(%rsp,%rax,4), %xmm0
addss 0x84(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39910a
movl $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0x90(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39913b
movq $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
xorl %eax, %eax
movss 0x30(%rsp,%rax,4), %xmm0
addss 0x20(%rsp,%rax,4), %xmm0
movss %xmm0, 0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39916c
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x38(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3991af
addq $0xc0, %rsp
popq %rbx
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<12, 9, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(decrement(in0)) + reduceToVec3(decrement(in0));
}
|
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
cmpl $0x2, %esi
jne 0x399273
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x662a9a(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x399215
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x39920a
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x399208
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x50(%rsp)
movss %xmm0, 0x58(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x5c(%rsp)
movss %xmm0, 0x64(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x68(%rsp)
movss %xmm0, 0x70(%rsp)
jmp 0x3992b6
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x672798(%rip), %rcx # 0xa0ba20
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x39928f
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39928a
leaq 0x9c(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3a74d3
movl $0x0, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
xorl %eax, %eax
movss 0x9c(%rsp,%rax,4), %xmm0
addss 0xa8(%rsp,%rax,4), %xmm0
movss %xmm0, 0x78(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3992de
movl $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
xorl %eax, %eax
movss 0x78(%rsp,%rax,4), %xmm0
addss 0xb4(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399312
leaq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3a74d3
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x78(%rsp,%rax,4), %xmm0
addss 0x84(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399352
movl $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0x90(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399383
movq $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
xorl %eax, %eax
movss 0x30(%rsp,%rax,4), %xmm0
addss 0x20(%rsp,%rax,4), %xmm0
movss %xmm0, 0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3993b4
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x38(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3993f7
addq $0xc0, %rsp
popq %rbx
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<13, 9, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(in0) + reduceToVec3(increment(in0));
}
|
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
cmpl $0x2, %esi
jne 0x3994b8
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x662854(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39945b
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x399450
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39944e
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, (%rsp)
movss %xmm0, 0x8(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x18(%rsp)
movss %xmm0, 0x20(%rsp)
jmp 0x3994fb
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x672553(%rip), %rcx # 0xa0ba20
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x3994d4
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x3994cf
movl $0x0, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
xorl %eax, %eax
movss (%rsp,%rax,4), %xmm0
addss 0xc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x78(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399511
movl $0x0, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
xorl %eax, %eax
movss 0x78(%rsp,%rax,4), %xmm0
addss 0x18(%rsp,%rax,4), %xmm0
movss %xmm0, 0x58(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39953e
leaq 0x78(%rsp), %rdi
movq %rsp, %rsi
callq 0x3a744a
movl $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
xorl %eax, %eax
movss 0x78(%rsp,%rax,4), %xmm0
addss 0x84(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399579
movl $0x0, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
xorl %eax, %eax
movss 0x30(%rsp,%rax,4), %xmm0
addss 0x90(%rsp,%rax,4), %xmm0
movss %xmm0, 0x48(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3995aa
movq $0x0, 0x68(%rsp)
movl $0x0, 0x70(%rsp)
xorl %eax, %eax
movss 0x58(%rsp,%rax,4), %xmm0
addss 0x48(%rsp,%rax,4), %xmm0
movss %xmm0, 0x68(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3995db
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x30(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x38(%rsp)
movl $0x2, 0x40(%rsp)
movl $0x2, %eax
movss 0x60(%rsp,%rax,4), %xmm0
movslq 0x30(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39961e
addq $0xa0, %rsp
popq %rbx
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<14, 9, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(in0) + reduceToVec3(decrement(in0));
}
|
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
cmpl $0x2, %esi
jne 0x3996de
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x66262e(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x399681
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x399676
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x399674
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, (%rsp)
movss %xmm0, 0x8(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x18(%rsp)
movss %xmm0, 0x20(%rsp)
jmp 0x399721
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x67232d(%rip), %rcx # 0xa0ba20
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x3996fa
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x3996f5
movl $0x0, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
xorl %eax, %eax
movss (%rsp,%rax,4), %xmm0
addss 0xc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x78(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399737
movl $0x0, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
xorl %eax, %eax
movss 0x78(%rsp,%rax,4), %xmm0
addss 0x18(%rsp,%rax,4), %xmm0
movss %xmm0, 0x58(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399764
leaq 0x78(%rsp), %rdi
movq %rsp, %rsi
callq 0x3a74d3
movl $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
xorl %eax, %eax
movss 0x78(%rsp,%rax,4), %xmm0
addss 0x84(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39979f
movl $0x0, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
xorl %eax, %eax
movss 0x30(%rsp,%rax,4), %xmm0
addss 0x90(%rsp,%rax,4), %xmm0
movss %xmm0, 0x48(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3997d0
movq $0x0, 0x68(%rsp)
movl $0x0, 0x70(%rsp)
xorl %eax, %eax
movss 0x58(%rsp,%rax,4), %xmm0
addss 0x48(%rsp,%rax,4), %xmm0
movss %xmm0, 0x68(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399801
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x30(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x38(%rsp)
movl $0x2, 0x40(%rsp)
movl $0x2, %eax
movss 0x60(%rsp,%rax,4), %xmm0
movslq 0x30(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x399844
addq $0xa0, %rsp
popq %rbx
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<8, 9, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
inline Vector<T, Size>::Vector (void)
{
for (int i = 0; i < Size; i++)
m_data[i] = T();
}
|
xorps %xmm0, %xmm0
leaq -0x58(%rsp), %rax
cmpl $0x2, %esi
jne 0x3998fc
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x662411(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39989e
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x399893
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x399891
movq 0x30(%rdi), %rax
movss 0x38(%rdi), %xmm0
movq %rax, -0x58(%rsp)
movss %xmm0, -0x50(%rsp)
movq 0x40(%rdi), %rax
movss 0x48(%rdi), %xmm0
movq %rax, -0x4c(%rsp)
movss %xmm0, -0x44(%rsp)
movq 0x50(%rdi), %rax
movss 0x58(%rdi), %xmm0
movq %rax, -0x40(%rsp)
movss %xmm0, -0x38(%rsp)
jmp 0x399941
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x67210f(%rip), %rcx # 0xa0ba20
xorl %edx, %edx
movq %rax, %rsi
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
movss %xmm0, (%rsi)
incq %r8
addq $0xc, %rsi
cmpq $0x3, %r8
jne 0x399919
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x399913
movss -0x48(%rsp), %xmm0
movss -0x58(%rsp), %xmm5
movss -0x54(%rsp), %xmm2
movss -0x4c(%rsp), %xmm6
movss -0x3c(%rsp), %xmm3
movss -0x40(%rsp), %xmm4
movaps %xmm4, %xmm1
mulss %xmm2, %xmm1
mulss %xmm6, %xmm2
mulss %xmm3, %xmm6
mulss %xmm5, %xmm3
mulss %xmm0, %xmm5
movss -0x38(%rsp), %xmm7
movss -0x50(%rsp), %xmm8
mulss %xmm8, %xmm6
mulss %xmm7, %xmm5
addss %xmm6, %xmm5
movss -0x44(%rsp), %xmm6
mulss %xmm6, %xmm1
addss %xmm5, %xmm1
mulss %xmm6, %xmm3
subss %xmm3, %xmm1
mulss %xmm7, %xmm2
subss %xmm2, %xmm1
mulss %xmm4, %xmm0
mulss %xmm8, %xmm0
subss %xmm0, %xmm1
xorl %eax, %eax
movss %xmm1, -0xc(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3999c3
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x28(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x20(%rsp)
movl $0x2, -0x18(%rsp)
movl $0x2, %eax
movss -0x14(%rsp,%rax,4), %xmm0
movslq -0x28(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3999fa
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<7, 9, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(inverse(in0));
}
|
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x399ab5
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x662258(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x399a57
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x399a4c
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x399a4a
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x48(%rsp)
movss %xmm0, 0x50(%rsp)
jmp 0x399af8
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x671f56(%rip), %rcx # 0xa0ba20
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x399ad1
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x399acc
leaq 0x5c(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x37f67e
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x5c(%rsp,%rax,4), %xmm0
addss 0x68(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399b1a
movl $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0x74(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399b48
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x399b8b
addq $0x80, %rsp
popq %rbx
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<6, 10, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(transpose(in0));
}
|
subq $0x28, %rsp
xorps %xmm0, %xmm0
leaq -0x10(%rsp), %rax
cmpl $0x2, %esi
jne 0x399c1f
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x6620cc(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x399be3
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x30, %rsi
jne 0x399bd8
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x399bd6
movups 0x30(%rdi), %xmm0
movaps %xmm0, -0x10(%rsp)
movups 0x40(%rdi), %xmm0
movaps %xmm0, (%rsp)
movups 0x50(%rdi), %xmm0
movaps %xmm0, 0x10(%rsp)
jmp 0x399c5a
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x671e3f(%rip), %rcx # 0xa0ba70
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x399c35
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rdx
jne 0x399c33
xorps %xmm0, %xmm0
leaq -0x40(%rsp), %rax
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x662029(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x399c86
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x30, %rsi
jne 0x399c7b
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x399c79
leaq -0x40(%rsp), %rax
leaq -0x10(%rsp), %rcx
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x399cb4
incq %rdx
addq $0xc, %rax
addq $0x4, %rcx
cmpq $0x4, %rdx
jne 0x399cb2
movl $0x0, -0x48(%rsp)
movq $0x0, -0x50(%rsp)
xorl %eax, %eax
movss -0x40(%rsp,%rax,4), %xmm0
addss -0x34(%rsp,%rax,4), %xmm0
movss %xmm0, -0x50(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399cec
movl $0x0, -0x70(%rsp)
movq $0x0, -0x78(%rsp)
xorl %eax, %eax
movss -0x50(%rsp,%rax,4), %xmm0
addss -0x28(%rsp,%rax,4), %xmm0
movss %xmm0, -0x78(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399d1a
movl $0x0, -0x58(%rsp)
movq $0x0, -0x60(%rsp)
xorl %eax, %eax
movss -0x78(%rsp,%rax,4), %xmm0
addss -0x1c(%rsp,%rax,4), %xmm0
movss %xmm0, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399d48
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x78(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x70(%rsp)
movl $0x2, -0x68(%rsp)
movl $0x2, %eax
movss -0x68(%rsp,%rax,4), %xmm0
movslq -0x78(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x399d8b
addq $0x28, %rsp
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<9, 10, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(in0);
}
|
pushq %rax
xorps %xmm0, %xmm0
leaq -0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x399e19
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x661ed3(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x399ddc
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x30, %rsi
jne 0x399dd1
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x399dcf
movups 0x30(%rdi), %xmm0
movaps %xmm0, -0x30(%rsp)
movups 0x40(%rdi), %xmm0
movaps %xmm0, -0x20(%rsp)
movups 0x50(%rdi), %xmm0
movaps %xmm0, -0x10(%rsp)
jmp 0x399e54
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x671c45(%rip), %rcx # 0xa0ba70
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x399e2f
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rdx
jne 0x399e2d
movq -0x30(%rsp), %rax
movss -0x28(%rsp), %xmm0
movq %rax, -0x3c(%rsp)
movss %xmm0, -0x34(%rsp)
movq -0x1c(%rsp), %rax
movss -0x14(%rsp), %xmm0
movq %rax, -0x48(%rsp)
movss %xmm0, -0x40(%rsp)
movq $0x0, -0x78(%rsp)
movl $0x0, -0x70(%rsp)
xorl %eax, %eax
movss -0x3c(%rsp,%rax,4), %xmm0
addss -0x48(%rsp,%rax,4), %xmm0
movss %xmm0, -0x78(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399e93
movq -0x8(%rsp), %rax
movss -0x10(%rsp), %xmm0
movq %rax, -0x54(%rsp)
movss %xmm0, -0x4c(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
movss -0x78(%rsp,%rax,4), %xmm0
addss -0x54(%rsp,%rax,4), %xmm0
movss %xmm0, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x399ed7
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x78(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x70(%rsp)
movl $0x2, -0x68(%rsp)
movl $0x2, %eax
movss -0x68(%rsp,%rax,4), %xmm0
movslq -0x78(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x399f1a
popq %rax
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<12, 10, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(decrement(in0)) + reduceToVec3(decrement(in0));
}
|
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rax
cmpl $0x2, %esi
jne 0x39a416
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x6618d9(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39a3d6
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x30, %rsi
jne 0x39a3cb
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39a3c9
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x60(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0x80(%rsp)
jmp 0x39a451
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x671648(%rip), %rcx # 0xa0ba70
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x39a42c
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rdx
jne 0x39a42a
leaq 0xc8(%rsp), %r14
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x3a7666
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, 0x20(%rsp)
movss %xmm0, 0x28(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x8(%rsp)
movss %xmm0, 0x10(%rsp)
movq $0x0, 0x98(%rsp)
movl $0x0, 0xa0(%rsp)
xorl %eax, %eax
movss 0x20(%rsp,%rax,4), %xmm0
addss 0x8(%rsp,%rax,4), %xmm0
movss %xmm0, 0x98(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a4a8
movq 0xf0(%rsp), %rax
movss 0xe8(%rsp), %xmm0
movq %rax, 0x14(%rsp)
movss %xmm0, 0x1c(%rsp)
movq $0x0, 0x48(%rsp)
movl $0x0, 0x50(%rsp)
xorl %eax, %eax
movss 0x98(%rsp,%rax,4), %xmm0
addss 0x14(%rsp,%rax,4), %xmm0
movss %xmm0, 0x48(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a4f5
leaq 0x98(%rsp), %r14
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x3a7666
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, 0x8(%rsp)
movss %xmm0, 0x10(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x14(%rsp)
movss %xmm0, 0x1c(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0x14(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a564
movq 0xc0(%rsp), %rax
movss 0xb8(%rsp), %xmm0
movq %rax, 0x54(%rsp)
movss %xmm0, 0x5c(%rsp)
movq $0x0, 0x38(%rsp)
movl $0x0, 0x40(%rsp)
xorl %eax, %eax
movss 0x20(%rsp,%rax,4), %xmm0
addss 0x54(%rsp,%rax,4), %xmm0
movss %xmm0, 0x38(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a5ae
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x48(%rsp,%rax,4), %xmm0
addss 0x38(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a5dc
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x20(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x28(%rsp)
movl $0x2, 0x30(%rsp)
movl $0x2, %eax
movss (%rsp,%rax,4), %xmm0
movslq 0x20(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39a61f
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<13, 10, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(in0) + reduceToVec3(increment(in0));
}
|
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
cmpl $0x2, %esi
jne 0x39a6bd
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x66162f(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39a680
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x30, %rsi
jne 0x39a675
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39a673
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x50(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x60(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
jmp 0x39a6f8
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x6713a1(%rip), %rcx # 0xa0ba70
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x39a6d3
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rdx
jne 0x39a6d1
movq 0x50(%rsp), %rax
movss 0x58(%rsp), %xmm0
movq %rax, 0x18(%rsp)
movss %xmm0, 0x20(%rsp)
movq 0x64(%rsp), %rax
movss 0x6c(%rsp), %xmm0
movq %rax, (%rsp)
movss %xmm0, 0x8(%rsp)
movq $0x0, 0x98(%rsp)
movl $0x0, 0xa0(%rsp)
xorl %eax, %eax
movss 0x18(%rsp,%rax,4), %xmm0
addss (%rsp,%rax,4), %xmm0
movss %xmm0, 0x98(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a73c
movq 0x78(%rsp), %rax
movss 0x70(%rsp), %xmm0
movq %rax, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
xorl %eax, %eax
movss 0x98(%rsp,%rax,4), %xmm0
addss 0xc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a782
leaq 0x98(%rsp), %r14
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x3a75e0
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, (%rsp)
movss %xmm0, 0x8(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
xorl %eax, %eax
movss (%rsp,%rax,4), %xmm0
addss 0xc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x18(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a7f0
movq 0xc0(%rsp), %rax
movss 0xb8(%rsp), %xmm0
movq %rax, 0x8c(%rsp)
movss %xmm0, 0x94(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
xorl %eax, %eax
movss 0x18(%rsp,%rax,4), %xmm0
addss 0x8c(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a83f
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x40(%rsp,%rax,4), %xmm0
addss 0x30(%rsp,%rax,4), %xmm0
movss %xmm0, (%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a86f
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x20(%rsp)
movl $0x2, 0x28(%rsp)
movl $0x2, %eax
movss -0x8(%rsp,%rax,4), %xmm0
movslq 0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39a8b1
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<14, 10, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(in0) + reduceToVec3(decrement(in0));
}
|
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
cmpl $0x2, %esi
jne 0x39a951
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x66139b(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39a914
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x30, %rsi
jne 0x39a909
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39a907
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x50(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x60(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
jmp 0x39a98c
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x67110d(%rip), %rcx # 0xa0ba70
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x39a967
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rdx
jne 0x39a965
movq 0x50(%rsp), %rax
movss 0x58(%rsp), %xmm0
movq %rax, 0x18(%rsp)
movss %xmm0, 0x20(%rsp)
movq 0x64(%rsp), %rax
movss 0x6c(%rsp), %xmm0
movq %rax, (%rsp)
movss %xmm0, 0x8(%rsp)
movq $0x0, 0x98(%rsp)
movl $0x0, 0xa0(%rsp)
xorl %eax, %eax
movss 0x18(%rsp,%rax,4), %xmm0
addss (%rsp,%rax,4), %xmm0
movss %xmm0, 0x98(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39a9d0
movq 0x78(%rsp), %rax
movss 0x70(%rsp), %xmm0
movq %rax, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
xorl %eax, %eax
movss 0x98(%rsp,%rax,4), %xmm0
addss 0xc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x40(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39aa16
leaq 0x98(%rsp), %r14
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x3a7666
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, (%rsp)
movss %xmm0, 0x8(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
xorl %eax, %eax
movss (%rsp,%rax,4), %xmm0
addss 0xc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x18(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39aa84
movq 0xc0(%rsp), %rax
movss 0xb8(%rsp), %xmm0
movq %rax, 0x8c(%rsp)
movss %xmm0, 0x94(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
xorl %eax, %eax
movss 0x18(%rsp,%rax,4), %xmm0
addss 0x8c(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39aad3
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x40(%rsp,%rax,4), %xmm0
addss 0x30(%rsp,%rax,4), %xmm0
movss %xmm0, (%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39ab03
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x20(%rsp)
movl $0x2, 0x28(%rsp)
movl $0x2, %eax
movss -0x8(%rsp,%rax,4), %xmm0
movslq 0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39ab45
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<6, 11, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(transpose(in0));
}
|
pushq %rax
xorps %xmm0, %xmm0
leaq -0x40(%rsp), %rax
cmpl $0x2, %esi
jne 0x39abda
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x661117(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39ab96
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x4, %rdx
jne 0x39ab8b
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39ab89
movq 0x30(%rdi), %rax
movq %rax, -0x40(%rsp)
movq 0x40(%rdi), %rax
movq %rax, -0x38(%rsp)
movq 0x50(%rdi), %rax
movq %rax, -0x30(%rsp)
movq 0x60(%rdi), %rax
movq %rax, -0x28(%rsp)
jmp 0x39ac13
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x670ee8(%rip), %rcx # 0xa0bad0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x39abec
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x10, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39abea
xorps %xmm0, %xmm0
leaq -0x20(%rsp), %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x661074(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39ac3b
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x10, %rsi
je 0x39ac30
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39ac2e
leaq -0x20(%rsp), %rax
leaq -0x40(%rsp), %rcx
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,8), %xmm0
movss %xmm0, (%rax,%rsi,4)
incq %rsi
cmpq $0x4, %rsi
jne 0x39ac69
leaq 0x1(%rdx), %rsi
addq $0x10, %rax
addq $0x4, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39ac67
movq -0x20(%rsp), %rax
movss -0x18(%rsp), %xmm0
movq %rax, -0x68(%rsp)
movss %xmm0, -0x60(%rsp)
movq -0xc(%rsp), %rax
movss -0x4(%rsp), %xmm0
movq %rax, -0x4c(%rsp)
movss %xmm0, -0x44(%rsp)
movq $0x0, -0x78(%rsp)
movl $0x0, -0x70(%rsp)
xorl %eax, %eax
movss -0x68(%rsp,%rax,4), %xmm0
addss -0x4c(%rsp,%rax,4), %xmm0
movss %xmm0, -0x78(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39accf
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x68(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x60(%rsp)
movl $0x2, -0x58(%rsp)
movl $0x2, %eax
movss -0x80(%rsp,%rax,4), %xmm0
movslq -0x68(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39ad12
popq %rax
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<9, 11, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
inline Vector<T, Size>::Vector (void)
{
for (int i = 0; i < Size; i++)
m_data[i] = T();
}
|
xorps %xmm0, %xmm0
leaq -0x48(%rsp), %rax
cmpl $0x2, %esi
jne 0x39ad9d
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x660f54(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39ad59
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x4, %rdx
jne 0x39ad4e
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39ad4c
movq 0x30(%rdi), %rax
movq %rax, -0x48(%rsp)
movq 0x40(%rdi), %rax
movq %rax, -0x40(%rsp)
movq 0x50(%rdi), %rax
movq %rax, -0x38(%rsp)
movq 0x60(%rdi), %rax
movq %rax, -0x30(%rsp)
jmp 0x39add6
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x670d25(%rip), %rcx # 0xa0bad0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x39adaf
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x10, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39adad
movss -0x48(%rsp), %xmm0
movss -0x40(%rsp), %xmm1
addss -0x44(%rsp), %xmm0
addss -0x30(%rsp), %xmm0
addss -0x3c(%rsp), %xmm1
addss -0x2c(%rsp), %xmm1
movss -0x38(%rsp), %xmm2
addss -0x34(%rsp), %xmm2
movss %xmm0, -0x24(%rsp)
movss %xmm1, -0x20(%rsp)
movss %xmm2, -0x1c(%rsp)
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x10(%rsp)
movl $0x2, -0x8(%rsp)
movl $0x2, %eax
movss -0x2c(%rsp,%rax,4), %xmm0
movslq -0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39ae40
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuVector.hpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<10, 11, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(negate(in0));
}
|
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %esi
jne 0x39aed3
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x660e1e(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39ae8f
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x4, %rdx
jne 0x39ae84
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39ae82
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rbx), %rax
movq %rax, 0x28(%rsp)
jmp 0x39af0c
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x670bef(%rip), %rcx # 0xa0bad0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x39aee5
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x10, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39aee3
leaq 0x48(%rsp), %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x3a76ec
movss (%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0x4(%r14), %xmm0
addss 0x18(%r14), %xmm0
addss 0xc(%r14), %xmm1
addss 0x1c(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x4(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x30(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x38(%rsp)
movl $0x2, 0x40(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x30(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39af87
addq $0x68, %rsp
popq %rbx
popq %r14
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<12, 11, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(decrement(in0)) + reduceToVec3(decrement(in0));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x39b202
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x660aef(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39b1be
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x4, %rdx
jne 0x39b1b3
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39b1b1
movq 0x30(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rbx), %rax
movq %rax, 0x48(%rsp)
jmp 0x39b23b
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x6708c0(%rip), %rcx # 0xa0bad0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x39b214
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x10, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39b212
leaq 0x90(%rsp), %r14
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a77e8
movss (%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0x4(%r14), %xmm0
addss 0x18(%r14), %xmm0
addss 0xc(%r14), %xmm1
addss 0x1c(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x28(%rsp)
movss %xmm2, 0x2c(%rsp)
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a77e8
movss (%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0x4(%r14), %xmm0
addss 0x18(%r14), %xmm0
addss 0xc(%r14), %xmm1
addss 0x1c(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x18(%rsp)
movss %xmm1, 0x1c(%rsp)
movss %xmm2, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x24(%rsp,%rax,4), %xmm0
addss 0x18(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39b2f8
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x58(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x60(%rsp)
movl $0x2, 0x68(%rsp)
movl $0x2, %eax
movss (%rsp,%rax,4), %xmm0
movslq 0x58(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39b33b
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<14, 11, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(in0) + reduceToVec3(decrement(in0));
}
|
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x39b596
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x66075b(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39b552
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x4, %rdx
jne 0x39b547
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39b545
movq 0x30(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rbx), %rax
movq %rax, 0x48(%rsp)
jmp 0x39b5cf
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x67052c(%rip), %rcx # 0xa0bad0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x4, %rsi
jne 0x39b5a8
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x10, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39b5a6
leaq 0x30(%rsp), %rsi
movss (%rsi), %xmm0
movss 0x8(%rsi), %xmm1
addss 0x4(%rsi), %xmm0
addss 0x18(%rsi), %xmm0
addss 0xc(%rsi), %xmm1
addss 0x1c(%rsi), %xmm1
movss 0x10(%rsi), %xmm2
addss 0x14(%rsi), %xmm2
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x28(%rsp)
movss %xmm2, 0x2c(%rsp)
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x3a77e8
movss (%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0x4(%r14), %xmm0
addss 0x18(%r14), %xmm0
addss 0xc(%r14), %xmm1
addss 0x1c(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x18(%rsp)
movss %xmm1, 0x1c(%rsp)
movss %xmm2, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x24(%rsp,%rax,4), %xmm0
addss 0x18(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39b66e
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x50(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x58(%rsp)
movl $0x2, 0x60(%rsp)
movl $0x2, %eax
movss (%rsp,%rax,4), %xmm0
movslq 0x50(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39b6b1
addq $0x88, %rsp
popq %rbx
popq %r14
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<6, 12, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(transpose(in0));
}
|
subq $0x38, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x39b77f
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x6605a2(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39b70d
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x30, %rsi
jne 0x39b702
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39b700
movq 0x30(%rdi), %rax
movss 0x38(%rdi), %xmm0
movq %rax, -0x30(%rsp)
movss %xmm0, -0x28(%rsp)
movq 0x40(%rdi), %rax
movss 0x48(%rdi), %xmm0
movq %rax, -0x24(%rsp)
movss %xmm0, -0x1c(%rsp)
movq 0x50(%rdi), %rax
movss 0x58(%rdi), %xmm0
movq %rax, -0x18(%rsp)
movss %xmm0, -0x10(%rsp)
movq 0x60(%rdi), %rax
movss 0x68(%rdi), %xmm0
movq %rax, -0xc(%rsp)
movss %xmm0, -0x4(%rsp)
jmp 0x39b7c1
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x67037f(%rip), %rcx # 0xa0bb10
xorl %edx, %edx
movq %rax, %rsi
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
movss %xmm0, (%rsi)
incq %r8
addq $0xc, %rsi
cmpq $0x4, %r8
jne 0x39b799
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x3, %rdx
jne 0x39b793
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x6604c4(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39b7eb
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x30, %rsi
jne 0x39b7e0
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39b7de
movq %rsp, %rax
leaq -0x30(%rsp), %rcx
xorl %edx, %edx
movq %rcx, %rsi
xorl %r8d, %r8d
movss (%rsi), %xmm0
movss %xmm0, (%rax,%r8,4)
incq %r8
addq $0xc, %rsi
cmpq $0x4, %r8
jne 0x39b81b
incq %rdx
addq $0x10, %rax
addq $0x4, %rcx
cmpq $0x3, %rdx
jne 0x39b815
movq (%rsp), %rax
movss 0x8(%rsp), %xmm0
movq %rax, -0x3c(%rsp)
movss %xmm0, -0x34(%rsp)
movq 0x14(%rsp), %rax
movss 0x1c(%rsp), %xmm0
movq %rax, -0x48(%rsp)
movss %xmm0, -0x40(%rsp)
movq $0x0, -0x78(%rsp)
movl $0x0, -0x70(%rsp)
xorl %eax, %eax
movss -0x3c(%rsp,%rax,4), %xmm0
addss -0x48(%rsp,%rax,4), %xmm0
movss %xmm0, -0x78(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39b881
movq 0x28(%rsp), %rax
movss 0x20(%rsp), %xmm0
movq %rax, -0x54(%rsp)
movss %xmm0, -0x4c(%rsp)
movq $0x0, -0x60(%rsp)
movl $0x0, -0x58(%rsp)
xorl %eax, %eax
movss -0x78(%rsp,%rax,4), %xmm0
addss -0x54(%rsp,%rax,4), %xmm0
movss %xmm0, -0x60(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39b8c5
addq $0x1f0, %rdi # imm = 0x1F0
movq %rdi, -0x78(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, -0x70(%rsp)
movl $0x2, -0x68(%rsp)
movl $0x2, %eax
movss -0x68(%rsp,%rax,4), %xmm0
movslq -0x78(%rsp,%rax,4), %rcx
movss %xmm0, (%rdi,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39b908
addq $0x38, %rsp
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<10, 13, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(negate(in0));
}
|
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rax
cmpl $0x2, %esi
jne 0x39cc75
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65f089(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39cc26
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x40, %rsi
jne 0x39cc1b
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39cc19
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x80(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0x90(%rsp)
movups 0x60(%rbx), %xmm0
movaps %xmm0, 0xa0(%rsp)
jmp 0x39ccb4
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66eee5(%rip), %rcx # 0xa0bb70
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0x10, %rsi
jne 0x39cc8f
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39cc8d
leaq 0xb8(%rsp), %r14
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0x3a79f7
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, 0x64(%rsp)
movss %xmm0, 0x6c(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x58(%rsp)
movss %xmm0, 0x60(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
xorl %eax, %eax
movss 0x64(%rsp,%rax,4), %xmm0
addss 0x58(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39cd05
movq 0xe0(%rsp), %rax
movss 0xd8(%rsp), %xmm0
movq %rax, 0x4c(%rsp)
movss %xmm0, 0x54(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x30(%rsp,%rax,4), %xmm0
addss 0x4c(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39cd4f
movss 0xf4(%rsp), %xmm0
movss 0xe8(%rsp), %xmm1
movss 0xec(%rsp), %xmm2
movss %xmm0, 0x40(%rsp)
movss %xmm1, 0x44(%rsp)
movss %xmm2, 0x48(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0x40(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39cdaa
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39cded
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<11, 13, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
// modifying reduction: sum modified value too
evalCtx.color.xyz() = reduceToVec3(increment(in0)) + reduceToVec3(increment(in0));
}
|
pushq %r14
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rax
cmpl $0x2, %esi
jne 0x39cea9
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65ee58(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39ce57
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x40, %rsi
jne 0x39ce4c
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39ce4a
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0xb0(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0xc0(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0xd0(%rsp)
movups 0x60(%rbx), %xmm0
movaps %xmm0, 0xe0(%rsp)
jmp 0x39cee8
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66ecb1(%rip), %rcx # 0xa0bb70
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0x10, %rsi
jne 0x39cec3
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39cec1
leaq 0xf8(%rsp), %r14
leaq 0xb0(%rsp), %rsi
movq %r14, %rdi
callq 0x3a7a7f
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, (%rsp)
movss %xmm0, 0x8(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
xorl %eax, %eax
movss (%rsp,%rax,4), %xmm0
addss 0x3c(%rsp,%rax,4), %xmm0
movss %xmm0, 0x18(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39cf3b
movq 0x120(%rsp), %rax
movss 0x118(%rsp), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq $0x0, 0x70(%rsp)
movl $0x0, 0x78(%rsp)
xorl %eax, %eax
movss 0x18(%rsp,%rax,4), %xmm0
addss 0x30(%rsp,%rax,4), %xmm0
movss %xmm0, 0x70(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39cf84
movss 0x134(%rsp), %xmm0
movss 0x128(%rsp), %xmm1
movss 0x12c(%rsp), %xmm2
movss %xmm0, 0xc(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm2, 0x14(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
xorl %eax, %eax
movss 0x70(%rsp,%rax,4), %xmm0
addss 0xc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x58(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39cfdf
leaq 0x70(%rsp), %r14
leaq 0xb0(%rsp), %rsi
movq %r14, %rdi
callq 0x3a7a7f
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x3c(%rsp,%rax,4), %xmm0
addss 0x30(%rsp,%rax,4), %xmm0
movss %xmm0, (%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39d04a
movq 0x98(%rsp), %rax
movss 0x90(%rsp), %xmm0
movq %rax, 0xc(%rsp)
movss %xmm0, 0x14(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
xorl %eax, %eax
movss (%rsp,%rax,4), %xmm0
addss 0xc(%rsp,%rax,4), %xmm0
movss %xmm0, 0x18(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39d093
movss 0xac(%rsp), %xmm0
movss 0xa0(%rsp), %xmm1
movss 0xa4(%rsp), %xmm2
movss %xmm0, 0x64(%rsp)
movss %xmm1, 0x68(%rsp)
movss %xmm2, 0x6c(%rsp)
movq $0x0, 0x48(%rsp)
movl $0x0, 0x50(%rsp)
xorl %eax, %eax
movss 0x18(%rsp,%rax,4), %xmm0
addss 0x64(%rsp,%rax,4), %xmm0
movss %xmm0, 0x48(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39d0ed
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x58(%rsp,%rax,4), %xmm0
addss 0x48(%rsp,%rax,4), %xmm0
movss %xmm0, (%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39d11a
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x20(%rsp)
movl $0x2, 0x28(%rsp)
movl $0x2, %eax
movss -0x8(%rsp,%rax,4), %xmm0
movslq 0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39d15c
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r14
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<7, 13, 94>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
DE_UNREF(in1Type);
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
evalCtx.color.xyz() = reduceToVec3(inverse(in0));
}
|
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rax
cmpl $0x2, %esi
jne 0x39dd77
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65df87(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39dd28
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x40, %rsi
jne 0x39dd1d
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39dd1b
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x80(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0x90(%rsp)
movups 0x60(%rbx), %xmm0
movaps %xmm0, 0xa0(%rsp)
jmp 0x39ddb6
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66dde3(%rip), %rcx # 0xa0bb70
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0x10, %rsi
jne 0x39dd91
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39dd8f
leaq 0xb8(%rsp), %r14
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0x37fb80
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, 0x64(%rsp)
movss %xmm0, 0x6c(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x58(%rsp)
movss %xmm0, 0x60(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x38(%rsp)
xorl %eax, %eax
movss 0x64(%rsp,%rax,4), %xmm0
addss 0x58(%rsp,%rax,4), %xmm0
movss %xmm0, 0x30(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39de07
movq 0xe0(%rsp), %rax
movss 0xd8(%rsp), %xmm0
movq %rax, 0x4c(%rsp)
movss %xmm0, 0x54(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x30(%rsp,%rax,4), %xmm0
addss 0x4c(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39de51
movss 0xf4(%rsp), %xmm0
movss 0xe8(%rsp), %xmm1
movss 0xec(%rsp), %xmm2
movss %xmm0, 0x40(%rsp)
movss %xmm1, 0x44(%rsp)
movss %xmm2, 0x48(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0x40(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39deac
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39deef
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<15, 5, 5>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 + in1);
}
|
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
cmpl $0x2, %esi
jne 0x39df77
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65dd68(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39df45
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x39df3a
leaq 0x1(%rcx), %rsi
addq $0x4, %rax
testq %rcx, %rcx
movq %rsi, %rcx
je 0x39df38
movq 0x30(%rbx), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x28(%rsp)
jmp 0x39dfac
movaps %xmm0, (%rax)
leaq 0x66d9df(%rip), %rcx # 0xa0b960
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq $0x1, %rdi
je 0x39df85
leaq 0x1(%rsi), %rdi
addq $0x4, %rax
addq $0x8, %rcx
testq %rsi, %rsi
movq %rdi, %rsi
je 0x39df83
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39e005
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65dcda(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39dfd3
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0x39dfc8
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39dfc6
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
jmp 0x39e03a
movaps %xmm0, (%rax)
leaq 0x66d961(%rip), %rcx # 0xa0b970
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x39e013
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x8, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39e011
leaq 0x48(%rsp), %r14
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x386f6d
movss 0x8(%r14), %xmm0
movss (%r14), %xmm1
movss 0x4(%r14), %xmm2
addss 0xc(%r14), %xmm2
movss %xmm1, 0x4(%rsp)
movss %xmm0, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x30(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x38(%rsp)
movl $0x2, 0x40(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x30(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39e0a2
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<16, 5, 5>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 - in1);
}
|
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
cmpl $0x2, %esi
jne 0x39e127
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65dbb8(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39e0f5
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x39e0ea
leaq 0x1(%rcx), %rsi
addq $0x4, %rax
testq %rcx, %rcx
movq %rsi, %rcx
je 0x39e0e8
movq 0x30(%rbx), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x28(%rsp)
jmp 0x39e15c
movaps %xmm0, (%rax)
leaq 0x66d82f(%rip), %rcx # 0xa0b960
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq $0x1, %rdi
je 0x39e135
leaq 0x1(%rsi), %rdi
addq $0x4, %rax
addq $0x8, %rcx
testq %rsi, %rsi
movq %rdi, %rsi
je 0x39e133
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39e1b5
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65db2a(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39e183
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0x39e178
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39e176
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
jmp 0x39e1ea
movaps %xmm0, (%rax)
leaq 0x66d7b1(%rip), %rcx # 0xa0b970
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x39e1c3
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x8, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39e1c1
leaq 0x48(%rsp), %r14
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x387067
movss 0x8(%r14), %xmm0
movss (%r14), %xmm1
movss 0x4(%r14), %xmm2
addss 0xc(%r14), %xmm2
movss %xmm1, 0x4(%rsp)
movss %xmm0, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x30(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x38(%rsp)
movl $0x2, 0x40(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x30(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39e252
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<18, 5, 5>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 / in1);
}
|
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
cmpl $0x2, %esi
jne 0x39e2d7
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65da08(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39e2a5
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x39e29a
leaq 0x1(%rcx), %rsi
addq $0x4, %rax
testq %rcx, %rcx
movq %rsi, %rcx
je 0x39e298
movq 0x30(%rbx), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x28(%rsp)
jmp 0x39e30c
movaps %xmm0, (%rax)
leaq 0x66d67f(%rip), %rcx # 0xa0b960
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq $0x1, %rdi
je 0x39e2e5
leaq 0x1(%rsi), %rdi
addq $0x4, %rax
addq $0x8, %rcx
testq %rsi, %rsi
movq %rdi, %rsi
je 0x39e2e3
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39e365
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65d97a(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39e333
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0x39e328
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39e326
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
jmp 0x39e39a
movaps %xmm0, (%rax)
leaq 0x66d601(%rip), %rcx # 0xa0b970
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x39e373
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x8, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39e371
leaq 0x48(%rsp), %r14
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x3a42bb
movss 0x8(%r14), %xmm0
movss (%r14), %xmm1
movss 0x4(%r14), %xmm2
addss 0xc(%r14), %xmm2
movss %xmm1, 0x4(%rsp)
movss %xmm0, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x30(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x38(%rsp)
movl $0x2, 0x40(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x30(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39e402
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<17, 5, 5>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 * in1);
}
|
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
cmpl $0x2, %esi
jne 0x39e487
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65d858(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39e455
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x39e44a
leaq 0x1(%rcx), %rsi
addq $0x4, %rax
testq %rcx, %rcx
movq %rsi, %rcx
je 0x39e448
movq 0x30(%rbx), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x28(%rsp)
jmp 0x39e4bc
movaps %xmm0, (%rax)
leaq 0x66d4cf(%rip), %rcx # 0xa0b960
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq $0x1, %rdi
je 0x39e495
leaq 0x1(%rsi), %rdi
addq $0x4, %rax
addq $0x8, %rcx
testq %rsi, %rsi
movq %rdi, %rsi
je 0x39e493
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39e515
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65d7ca(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39e4e3
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x1, %rdx
je 0x39e4d8
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39e4d6
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
jmp 0x39e54a
movaps %xmm0, (%rax)
leaq 0x66d451(%rip), %rcx # 0xa0b970
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x39e523
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0x8, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39e521
leaq 0x48(%rsp), %r14
leaq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x347dbe
movss 0x8(%r14), %xmm0
movss (%r14), %xmm1
movss 0x4(%r14), %xmm2
addss 0xc(%r14), %xmm2
movss %xmm1, 0x4(%rsp)
movss %xmm0, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x30(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x38(%rsp)
movl $0x2, 0x40(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x30(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39e5b2
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<15, 6, 6>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 + in1);
}
|
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x39e65a
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65d69f(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x39e610
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0xc, %rdi
cmpq $0xc, %rdi
je 0x39e605
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39e603
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
jmp 0x39e69c
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66d314(%rip), %rcx # 0xa0b980
xorl %esi, %esi
movq %rax, %rdi
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
movss %xmm0, (%rdi)
incq %r8
addq $0xc, %rdi
cmpq $0x1, %r8
je 0x39e674
incq %rsi
addq $0x4, %rax
addq $0x8, %rcx
cmpq $0x3, %rsi
jne 0x39e66e
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39e717
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65d5e2(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39e6cd
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0xc, %rsi
je 0x39e6c2
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39e6c0
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x10(%rsp)
movss %xmm0, 0x18(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x1c(%rsp)
movss %xmm0, 0x24(%rsp)
jmp 0x39e757
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66d26f(%rip), %rcx # 0xa0b998
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x1, %rdi
je 0x39e730
incq %rdx
addq $0x4, %rax
addq $0x8, %rcx
cmpq $0x3, %rdx
jne 0x39e72b
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x3a44dd
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
xorl %eax, %eax
movss 0x68(%rsp,%rax,4), %xmm0
addss 0x74(%rsp,%rax,4), %xmm0
movss %xmm0, (%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39e77d
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x50(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x58(%rsp)
movl $0x2, 0x60(%rsp)
movl $0x2, %eax
movss -0x8(%rsp,%rax,4), %xmm0
movslq 0x50(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39e7bf
addq $0x80, %rsp
popq %rbx
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<18, 6, 6>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 / in1);
}
|
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x39ea76
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65d283(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x39ea2c
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0xc, %rdi
cmpq $0xc, %rdi
je 0x39ea21
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39ea1f
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
jmp 0x39eab8
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66cef8(%rip), %rcx # 0xa0b980
xorl %esi, %esi
movq %rax, %rdi
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
movss %xmm0, (%rdi)
incq %r8
addq $0xc, %rdi
cmpq $0x1, %r8
je 0x39ea90
incq %rsi
addq $0x4, %rax
addq $0x8, %rcx
cmpq $0x3, %rsi
jne 0x39ea8a
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39eb33
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65d1c6(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39eae9
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0xc, %rsi
je 0x39eade
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39eadc
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x10(%rsp)
movss %xmm0, 0x18(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x1c(%rsp)
movss %xmm0, 0x24(%rsp)
jmp 0x39eb73
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66ce53(%rip), %rcx # 0xa0b998
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x1, %rdi
je 0x39eb4c
incq %rdx
addq $0x4, %rax
addq $0x8, %rcx
cmpq $0x3, %rdx
jne 0x39eb47
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x3a45ef
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
xorl %eax, %eax
movss 0x68(%rsp,%rax,4), %xmm0
addss 0x74(%rsp,%rax,4), %xmm0
movss %xmm0, (%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39eb99
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x50(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x58(%rsp)
movl $0x2, 0x60(%rsp)
movl $0x2, %eax
movss -0x8(%rsp,%rax,4), %xmm0
movslq 0x50(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39ebdb
addq $0x80, %rsp
popq %rbx
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<15, 7, 7>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 + in1);
}
|
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rax
cmpl $0x2, %esi
jne 0x39ec6c
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65d077(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x39ec38
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0x10, %rdi
cmpq $0x10, %rdi
je 0x39ec2d
incq %rsi
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rsi
jne 0x39ec2b
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x60(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
jmp 0x39eca3
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66cd36(%rip), %rcx # 0xa0b9b0
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi), %xmm0
movss %xmm0, (%rax,%rdi,4)
addq $0x4, %rdi
cmpq $0x4, %rdi
je 0x39ec7e
incq %rsi
addq $0x4, %rax
addq $0x8, %rcx
cmpq $0x4, %rsi
jne 0x39ec7c
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
cmpl $0x2, %edx
jne 0x39ed04
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65cfdf(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39ecd0
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x10, %rsi
je 0x39ecc5
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x39ecc3
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x50(%rsp)
jmp 0x39ed3b
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66ccbe(%rip), %rcx # 0xa0b9d0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0x4, %rsi
je 0x39ed16
incq %rdx
addq $0x4, %rax
addq $0x8, %rcx
cmpq $0x4, %rdx
jne 0x39ed14
leaq 0x88(%rsp), %r14
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
callq 0x3a48ee
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, 0x18(%rsp)
movss %xmm0, 0x20(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x34(%rsp)
movss %xmm0, 0x3c(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x18(%rsp,%rax,4), %xmm0
addss 0x34(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39ed91
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x18(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x20(%rsp)
movl $0x2, 0x28(%rsp)
movl $0x2, %eax
movss (%rsp,%rax,4), %xmm0
movslq 0x18(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39edd4
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<15, 8, 8>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 + in1);
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x39f260
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65ca88(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39f225
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x39f21a
leaq 0x1(%rcx), %rsi
addq $0x4, %rax
testq %rcx, %rcx
movq %rsi, %rcx
je 0x39f218
movq 0x30(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%rsp)
jmp 0x39f29d
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66c77e(%rip), %rcx # 0xa0b9f0
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq $0x3, %rdi
jne 0x39f276
leaq 0x1(%rsi), %rdi
addq $0x4, %rax
addq $0xc, %rcx
testq %rsi, %rsi
movq %rdi, %rsi
je 0x39f274
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39f307
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65c9e1(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39f2cc
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x39f2c1
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39f2bf
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x20(%rsp)
jmp 0x39f344
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66c6ef(%rip), %rcx # 0xa0ba08
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x39f31d
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0xc, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39f31b
leaq 0x60(%rsp), %r14
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x3a4ce6
movss (%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0x4(%r14), %xmm0
addss 0xc(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x4(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x48(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x50(%rsp)
movl $0x2, 0x58(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x48(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39f3b8
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<16, 8, 8>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 - in1);
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x39f44e
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65c89a(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39f413
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x39f408
leaq 0x1(%rcx), %rsi
addq $0x4, %rax
testq %rcx, %rcx
movq %rsi, %rcx
je 0x39f406
movq 0x30(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%rsp)
jmp 0x39f48b
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66c590(%rip), %rcx # 0xa0b9f0
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq $0x3, %rdi
jne 0x39f464
leaq 0x1(%rsi), %rdi
addq $0x4, %rax
addq $0xc, %rcx
testq %rsi, %rsi
movq %rdi, %rsi
je 0x39f462
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39f4f5
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65c7f3(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39f4ba
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x39f4af
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39f4ad
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x20(%rsp)
jmp 0x39f532
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66c501(%rip), %rcx # 0xa0ba08
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x39f50b
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0xc, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39f509
leaq 0x60(%rsp), %r14
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x3a4d67
movss (%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0x4(%r14), %xmm0
addss 0xc(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x4(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x48(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x50(%rsp)
movl $0x2, 0x58(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x48(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39f5a6
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<18, 8, 8>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 / in1);
}
|
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %esi
jne 0x39f63c
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65c6ac(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39f601
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x39f5f6
leaq 0x1(%rcx), %rsi
addq $0x4, %rax
testq %rcx, %rcx
movq %rsi, %rcx
je 0x39f5f4
movq 0x30(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x40(%rsp)
jmp 0x39f679
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66c3a2(%rip), %rcx # 0xa0b9f0
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq $0x3, %rdi
jne 0x39f652
leaq 0x1(%rsi), %rdi
addq $0x4, %rax
addq $0xc, %rcx
testq %rsi, %rsi
movq %rdi, %rsi
je 0x39f650
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
cmpl $0x2, %edx
jne 0x39f6e3
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movss 0x65c605(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
movaps %xmm0, %xmm1
cmpq %rdx, %rcx
je 0x39f6a8
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq $0x3, %rdx
jne 0x39f69d
leaq 0x1(%rcx), %rdx
addq $0x4, %rax
testq %rcx, %rcx
movq %rdx, %rcx
je 0x39f69b
movq 0x30(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rbx), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rbx), %rax
movq %rax, 0x20(%rsp)
jmp 0x39f720
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x66c313(%rip), %rcx # 0xa0ba08
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq $0x3, %rsi
jne 0x39f6f9
leaq 0x1(%rdx), %rsi
addq $0x4, %rax
addq $0xc, %rcx
testq %rdx, %rdx
movq %rsi, %rdx
je 0x39f6f7
leaq 0x60(%rsp), %r14
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x3a4de8
movss (%r14), %xmm0
movss 0x8(%r14), %xmm1
addss 0x4(%r14), %xmm0
addss 0xc(%r14), %xmm1
movss 0x10(%r14), %xmm2
addss 0x14(%r14), %xmm2
movss %xmm0, 0x4(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm2, 0xc(%rsp)
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x48(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x50(%rsp)
movl $0x2, 0x58(%rsp)
movl $0x2, %eax
movss -0x4(%rsp,%rax,4), %xmm0
movslq 0x48(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39f794
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<15, 9, 9>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 + in1);
}
|
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rax
cmpl $0x2, %esi
jne 0x39f85a
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x65c4b6(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x39f7f9
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0xc, %rdi
cmpq $0x24, %rdi
jne 0x39f7ee
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39f7ec
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x60(%rsp)
movss %xmm0, 0x68(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x6c(%rsp)
movss %xmm0, 0x74(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x78(%rsp)
movss %xmm0, 0x80(%rsp)
jmp 0x39f89f
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x66c1b1(%rip), %rcx # 0xa0ba20
xorl %esi, %esi
movq %rax, %rdi
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
movss %xmm0, (%rdi)
incq %r8
addq $0xc, %rdi
cmpq $0x3, %r8
jne 0x39f877
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39f871
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %edx
jne 0x39f935
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x65c3d8(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39f8d7
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x39f8cc
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39f8ca
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x48(%rsp)
movss %xmm0, 0x50(%rsp)
jmp 0x39f978
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x66c0fa(%rip), %rcx # 0xa0ba44
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x39f951
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39f94c
leaq 0x8c(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3a50a9
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x8c(%rsp,%rax,4), %xmm0
addss 0x98(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39f9a2
movl $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0xa4(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39f9d6
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39fa1c
addq $0xb0, %rsp
popq %rbx
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<16, 9, 9>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 - in1);
}
|
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rax
cmpl $0x2, %esi
jne 0x39fae2
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x65c22e(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x39fa81
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0xc, %rdi
cmpq $0x24, %rdi
jne 0x39fa76
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39fa74
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x60(%rsp)
movss %xmm0, 0x68(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x6c(%rsp)
movss %xmm0, 0x74(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x78(%rsp)
movss %xmm0, 0x80(%rsp)
jmp 0x39fb27
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x66bf29(%rip), %rcx # 0xa0ba20
xorl %esi, %esi
movq %rax, %rdi
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
movss %xmm0, (%rdi)
incq %r8
addq $0xc, %rdi
cmpq $0x3, %r8
jne 0x39faff
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39faf9
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %edx
jne 0x39fbbd
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x65c150(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39fb5f
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x39fb54
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39fb52
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x48(%rsp)
movss %xmm0, 0x50(%rsp)
jmp 0x39fc00
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x66be72(%rip), %rcx # 0xa0ba44
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x39fbd9
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39fbd4
leaq 0x8c(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3a5132
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x8c(%rsp,%rax,4), %xmm0
addss 0x98(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39fc2a
movl $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0xa4(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39fc5e
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39fca4
addq $0xb0, %rsp
popq %rbx
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<18, 9, 9>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 / in1);
}
|
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rax
cmpl $0x2, %esi
jne 0x39fd6a
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x65bfa6(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x39fd09
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0xc, %rdi
cmpq $0x24, %rdi
jne 0x39fcfe
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39fcfc
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x60(%rsp)
movss %xmm0, 0x68(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x6c(%rsp)
movss %xmm0, 0x74(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x78(%rsp)
movss %xmm0, 0x80(%rsp)
jmp 0x39fdaf
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x66bca1(%rip), %rcx # 0xa0ba20
xorl %esi, %esi
movq %rax, %rdi
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
movss %xmm0, (%rdi)
incq %r8
addq $0xc, %rdi
cmpq $0x3, %r8
jne 0x39fd87
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39fd81
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %edx
jne 0x39fe45
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x65bec8(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x39fde7
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x39fddc
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39fdda
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x48(%rsp)
movss %xmm0, 0x50(%rsp)
jmp 0x39fe88
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x66bbea(%rip), %rcx # 0xa0ba44
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x39fe61
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x39fe5c
leaq 0x8c(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3a51bb
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x8c(%rsp,%rax,4), %xmm0
addss 0x98(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39feb2
movl $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0xa4(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x39fee6
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x39ff2c
addq $0xb0, %rsp
popq %rbx
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<17, 9, 9>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 * in1);
}
|
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rax
cmpl $0x2, %esi
jne 0x39fff2
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x65bd1e(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x39ff91
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0xc, %rdi
cmpq $0x24, %rdi
jne 0x39ff86
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x39ff84
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x60(%rsp)
movss %xmm0, 0x68(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x6c(%rsp)
movss %xmm0, 0x74(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x78(%rsp)
movss %xmm0, 0x80(%rsp)
jmp 0x3a0037
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x66ba19(%rip), %rcx # 0xa0ba20
xorl %esi, %esi
movq %rax, %rdi
xorl %r8d, %r8d
movss (%rcx,%r8,4), %xmm0
movss %xmm0, (%rdi)
incq %r8
addq $0xc, %rdi
cmpq $0x3, %r8
jne 0x3a000f
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rsi
jne 0x3a0009
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
cmpl $0x2, %edx
jne 0x3a00cd
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
xorl %ecx, %ecx
movss 0x65bc40(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x3a006f
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0xc, %rsi
cmpq $0x24, %rsi
jne 0x3a0064
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x3a0062
movq 0x30(%rbx), %rax
movss 0x38(%rbx), %xmm0
movq %rax, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movq 0x40(%rbx), %rax
movss 0x48(%rbx), %xmm0
movq %rax, 0x3c(%rsp)
movss %xmm0, 0x44(%rsp)
movq 0x50(%rbx), %rax
movss 0x58(%rbx), %xmm0
movq %rax, 0x48(%rsp)
movss %xmm0, 0x50(%rsp)
jmp 0x3a0110
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movl $0x0, 0x20(%rax)
leaq 0x66b962(%rip), %rcx # 0xa0ba44
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movss (%rcx,%rdi,4), %xmm0
movss %xmm0, (%rsi)
incq %rdi
addq $0xc, %rsi
cmpq $0x3, %rdi
jne 0x3a00e9
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x3, %rdx
jne 0x3a00e4
leaq 0x8c(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3a5374
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
movss 0x8c(%rsp,%rax,4), %xmm0
addss 0x98(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3a013a
movl $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0xa4(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3a016e
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3a01b4
addq $0xb0, %rsp
popq %rbx
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<16, 10, 10>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 - in1);
}
|
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rax
cmpl $0x2, %esi
jne 0x3a04d3
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65b822(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x3a048d
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0x10, %rdi
cmpq $0x30, %rdi
jne 0x3a0482
incq %rsi
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rsi
jne 0x3a0480
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x80(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x90(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0xa0(%rsp)
jmp 0x3a050e
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66b58b(%rip), %rcx # 0xa0ba70
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi), %xmm0
movss %xmm0, (%rax,%rdi,4)
addq $0x4, %rdi
cmpq $0xc, %rdi
jne 0x3a04e9
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rsi
jne 0x3a04e7
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
cmpl $0x2, %edx
jne 0x3a057c
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65b770(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x3a053f
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x30, %rsi
jne 0x3a0534
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x3a0532
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x50(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x60(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
jmp 0x3a05b7
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66b512(%rip), %rcx # 0xa0baa0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x3a0592
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rdx
jne 0x3a0590
leaq 0xb8(%rsp), %r14
leaq 0x80(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x3a5543
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, 0x44(%rsp)
movss %xmm0, 0x4c(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x38(%rsp)
movss %xmm0, 0x40(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x44(%rsp,%rax,4), %xmm0
addss 0x38(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3a0610
movq 0xe0(%rsp), %rax
movss 0xd8(%rsp), %xmm0
movq %rax, 0x2c(%rsp)
movss %xmm0, 0x34(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0x2c(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3a065a
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3a069d
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
deqp::gles3::Functional::MatrixCaseUtils::Evaluator<18, 10, 10>::evaluate(deqp::gls::ShaderEvalContext&, deqp::gles3::Functional::MatrixCaseUtils::InputType, deqp::gles3::Functional::MatrixCaseUtils::InputType)
|
static void evaluate (ShaderEvalContext& evalCtx, InputType in0Type, InputType in1Type)
{
typename TypeTraits<In0DataType>::Type in0 = (in0Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In0DataType>(evalCtx, 0)
: getInputValue<INPUTTYPE_CONST, In0DataType>(evalCtx, 0);
typename TypeTraits<In1DataType>::Type in1 = (in1Type == INPUTTYPE_DYNAMIC) ? getInputValue<INPUTTYPE_DYNAMIC, In1DataType>(evalCtx, 1)
: getInputValue<INPUTTYPE_CONST, In1DataType>(evalCtx, 1);
evalCtx.color.xyz() = reduceToVec3(in0 / in1);
}
|
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rax
cmpl $0x2, %esi
jne 0x3a0749
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65b5ac(%rip), %xmm0 # 0x9fbca0
xorl %esi, %esi
xorl %edi, %edi
movaps %xmm0, %xmm1
cmpq %rdi, %rcx
je 0x3a0703
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rdi)
addq $0x10, %rdi
cmpq $0x30, %rdi
jne 0x3a06f8
incq %rsi
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rsi
jne 0x3a06f6
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x80(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x90(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0xa0(%rsp)
jmp 0x3a0784
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66b315(%rip), %rcx # 0xa0ba70
xorl %esi, %esi
xorl %edi, %edi
movss (%rcx,%rdi), %xmm0
movss %xmm0, (%rax,%rdi,4)
addq $0x4, %rdi
cmpq $0xc, %rdi
jne 0x3a075f
incq %rsi
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rsi
jne 0x3a075d
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rax
cmpl $0x2, %edx
jne 0x3a07f2
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movss 0x65b4fa(%rip), %xmm0 # 0x9fbca0
xorl %edx, %edx
xorl %esi, %esi
movaps %xmm0, %xmm1
cmpq %rsi, %rcx
je 0x3a07b5
xorps %xmm1, %xmm1
movss %xmm1, (%rax,%rsi)
addq $0x10, %rsi
cmpq $0x30, %rsi
jne 0x3a07aa
incq %rdx
addq $0x4, %rax
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x3a07a8
movups 0x30(%rbx), %xmm0
movaps %xmm0, 0x50(%rsp)
movups 0x40(%rbx), %xmm0
movaps %xmm0, 0x60(%rsp)
movups 0x50(%rbx), %xmm0
movaps %xmm0, 0x70(%rsp)
jmp 0x3a082d
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x66b29c(%rip), %rcx # 0xa0baa0
xorl %edx, %edx
xorl %esi, %esi
movss (%rcx,%rsi), %xmm0
movss %xmm0, (%rax,%rsi,4)
addq $0x4, %rsi
cmpq $0xc, %rsi
jne 0x3a0808
incq %rdx
addq $0x4, %rax
addq $0xc, %rcx
cmpq $0x4, %rdx
jne 0x3a0806
leaq 0xb8(%rsp), %r14
leaq 0x80(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x3a55c9
movq (%r14), %rax
movss 0x8(%r14), %xmm0
movq %rax, 0x44(%rsp)
movss %xmm0, 0x4c(%rsp)
movq 0x14(%r14), %rax
movss 0x1c(%r14), %xmm0
movq %rax, 0x38(%rsp)
movss %xmm0, 0x40(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
movss 0x44(%rsp,%rax,4), %xmm0
addss 0x38(%rsp,%rax,4), %xmm0
movss %xmm0, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3a0886
movq 0xe0(%rsp), %rax
movss 0xd8(%rsp), %xmm0
movq %rax, 0x2c(%rsp)
movss %xmm0, 0x34(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
xorl %eax, %eax
movss 0x8(%rsp,%rax,4), %xmm0
addss 0x2c(%rsp,%rax,4), %xmm0
movss %xmm0, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3a08d0
addq $0x1f0, %rbx # imm = 0x1F0
movq %rbx, 0x8(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x2, %eax
movss 0x18(%rsp,%rax,4), %xmm0
movslq 0x8(%rsp,%rax,4), %rcx
movss %xmm0, (%rbx,%rcx,4)
incq %rax
cmpq $0x5, %rax
jne 0x3a0913
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
nop
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
void deqp::gles3::Functional::MatrixCaseUtils::writeMatrixConstructor<3, 4>(std::ostream&, tcu::Matrix<float, 4, 3> const&)
|
void writeMatrixConstructor (std::ostream& str, const tcu::Matrix<float, Rows, Cols>& m)
{
if (Rows == Cols)
str << "mat" << Cols;
else
str << "mat" << Cols << "x" << Rows;
str << "(";
for (int colNdx = 0; colNdx < Cols; colNdx++)
{
for (int rowNdx = 0; rowNdx < Rows; rowNdx++)
{
if (rowNdx > 0 || colNdx > 0)
str << ", ";
str << de::floatToString(m(rowNdx, colNdx), 1);
}
}
str << ")";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6f8559(%rip), %rsi # 0xa9b1f9
movl $0x3, %edx
callq 0x325e70
movq %rbx, %rdi
movl $0x3, %esi
callq 0x325530
movq %rax, %r15
leaq 0x6a8f52(%rip), %rsi # 0xa4bc13
movl $0x1, %edx
movq %rax, %rdi
callq 0x325e70
movq %r15, %rdi
movl $0x4, %esi
callq 0x325530
leaq 0x694560(%rip), %rsi # 0xa37242
movl $0x1, %edx
movq %rbx, %rdi
callq 0x325e70
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
movl %r12d, %eax
orl %ebp, %eax
je 0x3a2d19
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x6e3a87(%rip), %rsi # 0xa8679b
callq 0x325e70
movss (%r14,%r12,4), %xmm0
movq %r15, %rdi
movl $0x1, %esi
callq 0x9f44da
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x325e70
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a2d55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3251a0
incq %r12
cmpq $0x4, %r12
jne 0x3a2cfe
incq %rbp
addq $0x10, %r14
cmpq $0x3, %rbp
jne 0x3a2cfb
leaq 0x707a0c(%rip), %rsi # 0xaaa77e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x325e70
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3a2da8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3251a0
movq %rbx, %rdi
callq 0x3259a0
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
tcu::Matrix<float, 2, 2> tcu::operator+<float, 2, 2>(tcu::Matrix<float, 2, 2> const&, float)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) + scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x658b2a(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm1, %xmm2
cmpq %r8, %rcx
je 0x3a3187
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r8,8)
incq %r8
cmpq $0x1, %r8
je 0x3a317c
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a3179
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x1, %rdx
je 0x3a31aa
leaq 0x1(%rcx), %rdx
addq $0x8, %rdi
addq $0x8, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a31a8
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 2> tcu::operator-<float, 2, 2>(tcu::Matrix<float, 2, 2> const&, float)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) - scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x658ab7(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm1, %xmm2
cmpq %r8, %rcx
je 0x3a31fa
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r8,8)
incq %r8
cmpq $0x1, %r8
je 0x3a31ef
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a31ec
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x1, %rdx
je 0x3a321d
leaq 0x1(%rcx), %rdx
addq $0x8, %rdi
addq $0x8, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a321b
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 2> tcu::operator*<float, 2, 2>(tcu::Matrix<float, 2, 2> const&, float)
|
Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) * scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x658a44(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm1, %xmm2
cmpq %r8, %rcx
je 0x3a326d
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r8,8)
incq %r8
cmpq $0x1, %r8
je 0x3a3262
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a325f
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x1, %rdx
je 0x3a3290
leaq 0x1(%rcx), %rdx
addq $0x8, %rdi
addq $0x8, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a328e
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 2> tcu::operator+<float, 3, 2>(tcu::Matrix<float, 3, 2> const&, float)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) + scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x658956(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a335e
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0xc, %r9
je 0x3a3353
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a3350
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a3383
leaq 0x1(%rcx), %rdx
addq $0xc, %rdi
addq $0xc, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a3381
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 2> tcu::operator-<float, 3, 2>(tcu::Matrix<float, 3, 2> const&, float)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) - scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x6588d6(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a33de
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0xc, %r9
je 0x3a33d3
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a33d0
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a3403
leaq 0x1(%rcx), %rdx
addq $0xc, %rdi
addq $0xc, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a3401
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 2> tcu::operator*<float, 3, 2>(tcu::Matrix<float, 3, 2> const&, float)
|
Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) * scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x658856(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a345e
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0xc, %r9
je 0x3a3453
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a3450
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a3483
leaq 0x1(%rcx), %rdx
addq $0xc, %rdi
addq $0xc, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a3481
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 2> tcu::operator/<float, 3, 2>(tcu::Matrix<float, 3, 2> const&, float)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) / scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x6587d6(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a34de
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0xc, %r9
je 0x3a34d3
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a34d0
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a3503
leaq 0x1(%rcx), %rdx
addq $0xc, %rdi
addq $0xc, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a3501
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 2> tcu::operator+<float, 4, 2>(tcu::Matrix<float, 4, 2> const&, float)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) + scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x65875a(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a355a
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a354f
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a354c
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a357f
leaq 0x1(%rcx), %rdx
addq $0x10, %rdi
addq $0x10, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a357d
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 2> tcu::operator-<float, 4, 2>(tcu::Matrix<float, 4, 2> const&, float)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) - scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x6586de(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a35d6
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a35cb
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a35c8
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a35fb
leaq 0x1(%rcx), %rdx
addq $0x10, %rdi
addq $0x10, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a35f9
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 2> tcu::operator*<float, 4, 2>(tcu::Matrix<float, 4, 2> const&, float)
|
Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) * scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x658662(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3652
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a3647
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a3644
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a3677
leaq 0x1(%rcx), %rdx
addq $0x10, %rdi
addq $0x10, %rsi
testq %rcx, %rcx
movq %rdx, %rcx
je 0x3a3675
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 3> tcu::operator*<float, 3, 3>(tcu::Matrix<float, 3, 3> const&, float)
|
Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) * scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
movl $0x0, 0x20(%rdi)
xorl %ecx, %ecx
movss 0x658283(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3a31
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0x24, %r9
jne 0x3a3a26
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a3a23
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a3a56
incq %rcx
addq $0xc, %rdi
addq $0xc, %rsi
cmpq $0x3, %rcx
jne 0x3a3a54
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 3> tcu::operator/<float, 3, 3>(tcu::Matrix<float, 3, 3> const&, float)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) / scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
movl $0x0, 0x20(%rdi)
xorl %ecx, %ecx
movss 0x658203(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3ab1
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0x24, %r9
jne 0x3a3aa6
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a3aa3
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a3ad6
incq %rcx
addq $0xc, %rdi
addq $0xc, %rsi
cmpq $0x3, %rcx
jne 0x3a3ad4
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 3> tcu::operator+<float, 4, 3>(tcu::Matrix<float, 4, 3> const&, float)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) + scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x658186(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3b2e
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a3b23
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a3b20
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a3b53
incq %rcx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq $0x3, %rcx
jne 0x3a3b51
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 3> tcu::operator-<float, 4, 3>(tcu::Matrix<float, 4, 3> const&, float)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) - scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x658109(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3bab
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a3ba0
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a3b9d
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a3bd0
incq %rcx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq $0x3, %rcx
jne 0x3a3bce
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 3> tcu::operator*<float, 4, 3>(tcu::Matrix<float, 4, 3> const&, float)
|
Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) * scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x65808c(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3c28
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a3c1d
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a3c1a
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a3c4d
incq %rcx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq $0x3, %rcx
jne 0x3a3c4b
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 3> tcu::operator/<float, 4, 3>(tcu::Matrix<float, 4, 3> const&, float)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) / scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x65800f(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3ca5
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a3c9a
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a3c97
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a3cca
incq %rcx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq $0x3, %rcx
jne 0x3a3cc8
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 4> tcu::operator+<float, 2, 4>(tcu::Matrix<float, 2, 4> const&, float)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) + scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657f96(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm1, %xmm2
cmpq %r8, %rcx
je 0x3a3d1b
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r8,8)
incq %r8
cmpq $0x4, %r8
jne 0x3a3d10
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a3d0d
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x1, %rdx
je 0x3a3d3e
incq %rcx
addq $0x8, %rdi
addq $0x8, %rsi
cmpq $0x4, %rcx
jne 0x3a3d3c
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 4> tcu::operator-<float, 2, 4>(tcu::Matrix<float, 2, 4> const&, float)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) - scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657f22(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm1, %xmm2
cmpq %r8, %rcx
je 0x3a3d8f
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r8,8)
incq %r8
cmpq $0x4, %r8
jne 0x3a3d84
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a3d81
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x1, %rdx
je 0x3a3db2
incq %rcx
addq $0x8, %rdi
addq $0x8, %rsi
cmpq $0x4, %rcx
jne 0x3a3db0
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 4> tcu::operator*<float, 2, 4>(tcu::Matrix<float, 2, 4> const&, float)
|
Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) * scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657eae(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
movaps %xmm1, %xmm2
cmpq %r8, %rcx
je 0x3a3e03
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r8,8)
incq %r8
cmpq $0x4, %r8
jne 0x3a3df8
leaq 0x1(%rcx), %r8
addq $0x4, %rdx
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a3df5
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x1, %rdx
je 0x3a3e26
incq %rcx
addq $0x8, %rdi
addq $0x8, %rsi
cmpq $0x4, %rcx
jne 0x3a3e24
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 4> tcu::operator+<float, 3, 4>(tcu::Matrix<float, 3, 4> const&, float)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) + scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657dc2(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3ef2
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0x30, %r9
jne 0x3a3ee7
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a3ee4
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a3f17
incq %rcx
addq $0xc, %rdi
addq $0xc, %rsi
cmpq $0x4, %rcx
jne 0x3a3f15
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 4> tcu::operator-<float, 3, 4>(tcu::Matrix<float, 3, 4> const&, float)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) - scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657d45(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3f6f
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0x30, %r9
jne 0x3a3f64
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a3f61
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a3f94
incq %rcx
addq $0xc, %rdi
addq $0xc, %rsi
cmpq $0x4, %rcx
jne 0x3a3f92
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 4> tcu::operator*<float, 3, 4>(tcu::Matrix<float, 3, 4> const&, float)
|
Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) * scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657cc8(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a3fec
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0x30, %r9
jne 0x3a3fe1
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a3fde
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a4011
incq %rcx
addq $0xc, %rdi
addq $0xc, %rsi
cmpq $0x4, %rcx
jne 0x3a400f
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 4> tcu::operator/<float, 3, 4>(tcu::Matrix<float, 3, 4> const&, float)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) / scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657c4b(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a4069
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0xc, %r9
cmpq $0x30, %r9
jne 0x3a405e
incq %r8
addq $0x4, %rdx
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a405b
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x3, %rdx
jne 0x3a408e
incq %rcx
addq $0xc, %rdi
addq $0xc, %rsi
cmpq $0x4, %rcx
jne 0x3a408c
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 4> tcu::operator+<float, 4, 4>(tcu::Matrix<float, 4, 4> const&, float)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) + scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x30(%rdi)
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657bca(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a40ea
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x40, %r9
jne 0x3a40df
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a40dc
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a410f
incq %rcx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq $0x4, %rcx
jne 0x3a410d
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 4> tcu::operator*<float, 4, 4>(tcu::Matrix<float, 4, 4> const&, float)
|
Matrix<T, Rows, Cols> operator* (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) * scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x30(%rdi)
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657ac8(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a41ec
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x40, %r9
jne 0x3a41e1
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a41de
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a4211
incq %rcx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq $0x4, %rcx
jne 0x3a420f
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 4> tcu::operator/<float, 4, 4>(tcu::Matrix<float, 4, 4> const&, float)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& mtx, T scalar)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = mtx(row, col) / scalar;
return res;
}
|
movq %rdi, %rax
xorps %xmm1, %xmm1
movups %xmm1, 0x30(%rdi)
movups %xmm1, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm1, (%rdi)
xorl %ecx, %ecx
movss 0x657a47(%rip), %xmm1 # 0x9fbca0
movq %rdi, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm1, %xmm2
cmpq %r9, %rcx
je 0x3a426d
xorps %xmm2, %xmm2
movss %xmm2, (%rdx,%r9)
addq $0x10, %r9
cmpq $0x40, %r9
jne 0x3a4262
incq %r8
addq $0x4, %rdx
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a425f
xorl %ecx, %ecx
xorl %edx, %edx
movss (%rsi,%rdx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%rdi,%rdx,4)
incq %rdx
cmpq $0x4, %rdx
jne 0x3a4292
incq %rcx
addq $0x10, %rdi
addq $0x10, %rsi
cmpq $0x4, %rcx
jne 0x3a4290
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 2> deqp::gles3::Functional::MatrixCaseUtils::matrixCompMult<float, 2, 2>(tcu::Matrix<float, 2, 2> const&, tcu::Matrix<float, 2, 2> const&)
|
tcu::Matrix<T, Rows, Cols> matrixCompMult (const tcu::Matrix<T, Rows, Cols>& a, const tcu::Matrix<T, Rows, Cols>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a(r,c) * b(r, c);
return retVal;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x657956(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a435b
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x1, %r9
je 0x3a4350
leaq 0x1(%rcx), %r9
addq $0x4, %r8
testq %rcx, %rcx
movq %r9, %rcx
je 0x3a434d
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,8), %xmm0
mulss (%rdx,%r8,8), %xmm0
movss %xmm0, (%rdi,%r8,8)
incq %r8
cmpq $0x1, %r8
je 0x3a437f
leaq 0x1(%rcx), %r8
addq $0x4, %rsi
addq $0x4, %rdx
addq $0x4, %rdi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a437c
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
tcu::Matrix<float, 2, 3> tcu::operator*<float, 2, 2, 2, 3>(tcu::Matrix<float, 2, 2> const&, tcu::Matrix<float, 2, 3> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x6578d2(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a43dc
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r8,8)
incq %r8
cmpq $0x3, %r8
jne 0x3a43d1
leaq 0x1(%rcx), %r8
addq $0x4, %rdi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a43ce
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,8), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
incq %r10
cmpq $0x1, %r10
je 0x3a440d
movss %xmm0, (%rdi,%r9,8)
incq %r9
addq $0x8, %r8
cmpq $0x3, %r9
jne 0x3a4407
leaq 0x1(%rcx), %rdi
addq $0x4, %rsi
testq %rcx, %rcx
movq %rdi, %rcx
je 0x3a43fd
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 4> tcu::operator*<float, 2, 2, 2, 4>(tcu::Matrix<float, 2, 2> const&, tcu::Matrix<float, 2, 4> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x65783f(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a446f
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r8,8)
incq %r8
cmpq $0x4, %r8
jne 0x3a4464
leaq 0x1(%rcx), %r8
addq $0x4, %rdi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a4461
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,8), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
incq %r10
cmpq $0x1, %r10
je 0x3a44a0
movss %xmm0, (%rdi,%r9,8)
incq %r9
addq $0x8, %r8
cmpq $0x4, %r9
jne 0x3a449a
leaq 0x1(%rcx), %rdi
addq $0x4, %rsi
testq %rcx, %rcx
movq %rdi, %rcx
je 0x3a4490
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 2> tcu::operator+<float, 3, 2>(tcu::Matrix<float, 3, 2> const&, tcu::Matrix<float, 3, 2> const&)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) + b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x6577a8(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a450c
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0xc, %r10
cmpq $0xc, %r10
je 0x3a4501
incq %r9
addq $0x4, %r8
addq $0xc, %rcx
cmpq $0x3, %r9
jne 0x3a44fe
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
addss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x3, %r8
jne 0x3a4532
leaq 0x1(%rcx), %r8
addq $0xc, %rdi
addq $0xc, %rdx
addq $0xc, %rsi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a452f
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 2> tcu::operator/<float, 3, 2>(tcu::Matrix<float, 3, 2> const&, tcu::Matrix<float, 3, 2> const&)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) / b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x657696(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a461e
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0xc, %r10
cmpq $0xc, %r10
je 0x3a4613
incq %r9
addq $0x4, %r8
addq $0xc, %rcx
cmpq $0x3, %r9
jne 0x3a4610
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
divss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x3, %r8
jne 0x3a4644
leaq 0x1(%rcx), %r8
addq $0xc, %rdi
addq $0xc, %rdx
addq $0xc, %rsi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a4641
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 2> tcu::operator*<float, 3, 2, 2, 2>(tcu::Matrix<float, 3, 2> const&, tcu::Matrix<float, 2, 2> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x657586(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a472b
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0xc, %r9
cmpq $0xc, %r9
je 0x3a4720
incq %r8
addq $0x4, %rdi
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a471d
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
movq %rsi, %r10
xorl %r11d, %r11d
movss (%r10), %xmm1
mulss (%r8,%r11,4), %xmm1
addss %xmm1, %xmm0
incq %r11
addq $0xc, %r10
cmpq $0x1, %r11
je 0x3a4761
leaq (%r9,%r9,2), %r10
movss %xmm0, (%rdi,%r10,4)
leaq 0x1(%r9), %r10
addq $0x8, %r8
testq %r9, %r9
movq %r10, %r9
je 0x3a4758
incq %rcx
addq $0x4, %rsi
cmpq $0x3, %rcx
jne 0x3a474e
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 3> tcu::operator*<float, 3, 2, 2, 3>(tcu::Matrix<float, 3, 2> const&, tcu::Matrix<float, 2, 3> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x0, 0x20(%rdi)
xorl %ecx, %ecx
movss 0x6574dd(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a47d4
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0xc, %r9
cmpq $0x24, %r9
jne 0x3a47c9
incq %r8
addq $0x4, %rdi
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a47c6
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
movq %rsi, %r10
xorl %r11d, %r11d
movss (%r10), %xmm1
mulss (%r8,%r11,4), %xmm1
addss %xmm1, %xmm0
incq %r11
addq $0xc, %r10
cmpq $0x1, %r11
je 0x3a480a
leaq (%r9,%r9,2), %r10
movss %xmm0, (%rdi,%r10,4)
incq %r9
addq $0x8, %r8
cmpq $0x3, %r9
jne 0x3a4801
incq %rcx
addq $0x4, %rsi
cmpq $0x3, %rcx
jne 0x3a47f7
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 4> tcu::operator*<float, 3, 2, 2, 4>(tcu::Matrix<float, 3, 2> const&, tcu::Matrix<float, 2, 4> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x65743a(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a4877
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0xc, %r9
cmpq $0x30, %r9
jne 0x3a486c
incq %r8
addq $0x4, %rdi
addq $0xc, %rcx
cmpq $0x3, %r8
jne 0x3a4869
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
movq %rsi, %r10
xorl %r11d, %r11d
movss (%r10), %xmm1
mulss (%r8,%r11,4), %xmm1
addss %xmm1, %xmm0
incq %r11
addq $0xc, %r10
cmpq $0x1, %r11
je 0x3a48ad
leaq (%r9,%r9,2), %r10
movss %xmm0, (%rdi,%r10,4)
incq %r9
addq $0x8, %r8
cmpq $0x4, %r9
jne 0x3a48a4
incq %rcx
addq $0x4, %rsi
cmpq $0x3, %rcx
jne 0x3a489a
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 2> tcu::operator+<float, 4, 2>(tcu::Matrix<float, 4, 2> const&, tcu::Matrix<float, 4, 2> const&)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) + b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x65739b(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a4919
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x10, %r10
je 0x3a490e
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a490b
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
addss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x3a493f
leaq 0x1(%rcx), %r8
addq $0x10, %rdi
addq $0x10, %rdx
addq $0x10, %rsi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a493c
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 2> tcu::operator-<float, 4, 2>(tcu::Matrix<float, 4, 2> const&, tcu::Matrix<float, 4, 2> const&)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) - b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x657316(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a499e
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x10, %r10
je 0x3a4993
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a4990
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
subss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x3a49c4
leaq 0x1(%rcx), %r8
addq $0x10, %rdi
addq $0x10, %rdx
addq $0x10, %rsi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a49c1
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 2> tcu::operator/<float, 4, 2>(tcu::Matrix<float, 4, 2> const&, tcu::Matrix<float, 4, 2> const&)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) / b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x657291(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a4a23
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x10, %r10
je 0x3a4a18
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a4a15
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
divss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x3a4a49
leaq 0x1(%rcx), %r8
addq $0x10, %rdi
addq $0x10, %rdx
addq $0x10, %rsi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a4a46
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 2> deqp::gles3::Functional::MatrixCaseUtils::matrixCompMult<float, 4, 2>(tcu::Matrix<float, 4, 2> const&, tcu::Matrix<float, 4, 2> const&)
|
tcu::Matrix<T, Rows, Cols> matrixCompMult (const tcu::Matrix<T, Rows, Cols>& a, const tcu::Matrix<T, Rows, Cols>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a(r,c) * b(r, c);
return retVal;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x65720c(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a4aa8
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x10, %r10
je 0x3a4a9d
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a4a9a
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8), %xmm0
mulss (%rdx,%r8), %xmm0
movss %xmm0, (%rdi,%r8)
addq $0x10, %r8
cmpq $0x10, %r8
je 0x3a4ace
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdx
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x3a4acb
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
tcu::Matrix<float, 4, 2> tcu::operator*<float, 4, 2, 2, 2>(tcu::Matrix<float, 4, 2> const&, tcu::Matrix<float, 2, 2> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x657189(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a4b28
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a4b1d
incq %r8
addq $0x4, %rdi
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a4b1a
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss (%r8,%r10), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0x4, %r10
je 0x3a4b5b
movq %r9, %r10
shlq $0x4, %r10
movss %xmm0, (%rdi,%r10)
leaq 0x1(%r9), %r10
addq $0x8, %r8
testq %r9, %r9
movq %r10, %r9
je 0x3a4b55
incq %rcx
addq $0x4, %rsi
cmpq $0x4, %rcx
jne 0x3a4b4b
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 3> tcu::operator*<float, 4, 2, 2, 3>(tcu::Matrix<float, 4, 2> const&, tcu::Matrix<float, 2, 3> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x6570e5(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a4bcc
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a4bc1
incq %r8
addq $0x4, %rdi
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a4bbe
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss (%r8,%r10), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0x4, %r10
je 0x3a4bff
movq %r9, %r10
shlq $0x4, %r10
movss %xmm0, (%rdi,%r10)
incq %r9
addq $0x8, %r8
cmpq $0x3, %r9
jne 0x3a4bf9
incq %rcx
addq $0x4, %rsi
cmpq $0x4, %rcx
jne 0x3a4bef
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 4> tcu::operator*<float, 4, 2, 2, 4>(tcu::Matrix<float, 4, 2> const&, tcu::Matrix<float, 2, 4> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x657040(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a4c71
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0x10, %r9
cmpq $0x40, %r9
jne 0x3a4c66
incq %r8
addq $0x4, %rdi
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a4c63
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss (%r8,%r10), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0x4, %r10
je 0x3a4ca4
movq %r9, %r10
shlq $0x4, %r10
movss %xmm0, (%rdi,%r10)
incq %r9
addq $0x8, %r8
cmpq $0x4, %r9
jne 0x3a4c9e
incq %rcx
addq $0x4, %rsi
cmpq $0x4, %rcx
jne 0x3a4c94
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 3> tcu::operator+<float, 2, 3>(tcu::Matrix<float, 2, 3> const&, tcu::Matrix<float, 2, 3> const&)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) + b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x656f9f(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a4d12
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x3, %r9
jne 0x3a4d07
leaq 0x1(%rcx), %r9
addq $0x4, %r8
testq %rcx, %rcx
movq %r9, %rcx
je 0x3a4d04
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
addss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x1, %r8
je 0x3a4d36
incq %rcx
addq $0x8, %rdi
addq $0x8, %rdx
addq $0x8, %rsi
cmpq $0x3, %rcx
jne 0x3a4d33
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 3> tcu::operator-<float, 2, 3>(tcu::Matrix<float, 2, 3> const&, tcu::Matrix<float, 2, 3> const&)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) - b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x656f1e(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a4d93
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x3, %r9
jne 0x3a4d88
leaq 0x1(%rcx), %r9
addq $0x4, %r8
testq %rcx, %rcx
movq %r9, %rcx
je 0x3a4d85
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
subss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x1, %r8
je 0x3a4db7
incq %rcx
addq $0x8, %rdi
addq $0x8, %rdx
addq $0x8, %rsi
cmpq $0x3, %rcx
jne 0x3a4db4
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 3> tcu::operator/<float, 2, 3>(tcu::Matrix<float, 2, 3> const&, tcu::Matrix<float, 2, 3> const&)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) / b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x656e9d(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a4e14
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x3, %r9
jne 0x3a4e09
leaq 0x1(%rcx), %r9
addq $0x4, %r8
testq %rcx, %rcx
movq %r9, %rcx
je 0x3a4e06
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
divss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x1, %r8
je 0x3a4e38
incq %rcx
addq $0x8, %rdi
addq $0x8, %rdx
addq $0x8, %rsi
cmpq $0x3, %rcx
jne 0x3a4e35
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 3> tcu::operator/<float, 3, 3>(tcu::Matrix<float, 3, 3> const&, tcu::Matrix<float, 3, 3> const&)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) / b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x0, 0x20(%rdi)
xorl %ecx, %ecx
movss 0x656ac7(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a51ed
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0xc, %r10
cmpq $0x24, %r10
jne 0x3a51e2
incq %r9
addq $0x4, %r8
addq $0xc, %rcx
cmpq $0x3, %r9
jne 0x3a51df
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
divss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x3, %r8
jne 0x3a5213
incq %rcx
addq $0xc, %rdi
addq $0xc, %rdx
addq $0xc, %rsi
cmpq $0x3, %rcx
jne 0x3a5210
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 3> deqp::gles3::Functional::MatrixCaseUtils::matrixCompMult<float, 3, 3>(tcu::Matrix<float, 3, 3> const&, tcu::Matrix<float, 3, 3> const&)
|
tcu::Matrix<T, Rows, Cols> matrixCompMult (const tcu::Matrix<T, Rows, Cols>& a, const tcu::Matrix<T, Rows, Cols>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a(r,c) * b(r, c);
return retVal;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x0, 0x20(%rdi)
xorl %ecx, %ecx
movss 0x656a3e(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a5276
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0xc, %r10
cmpq $0x24, %r10
jne 0x3a526b
incq %r9
addq $0x4, %r8
addq $0xc, %rcx
cmpq $0x3, %r9
jne 0x3a5268
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8), %xmm0
mulss (%rdx,%r8), %xmm0
movss %xmm0, (%rdi,%r8)
addq $0xc, %r8
cmpq $0x24, %r8
jne 0x3a529c
incq %rcx
addq $0x4, %rsi
addq $0x4, %rdx
addq $0x4, %rdi
cmpq $0x3, %rcx
jne 0x3a5299
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
tcu::Matrix<float, 4, 3> tcu::operator-<float, 4, 3>(tcu::Matrix<float, 4, 3> const&, tcu::Matrix<float, 4, 3> const&)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) - b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x656742(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a5572
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0x10, %r10
cmpq $0x30, %r10
jne 0x3a5567
incq %r9
addq $0x4, %r8
addq $0x10, %rcx
cmpq $0x4, %r9
jne 0x3a5564
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
subss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x4, %r8
jne 0x3a5598
incq %rcx
addq $0x10, %rdi
addq $0x10, %rdx
addq $0x10, %rsi
cmpq $0x3, %rcx
jne 0x3a5595
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 2> tcu::operator*<float, 4, 3, 3, 2>(tcu::Matrix<float, 4, 3> const&, tcu::Matrix<float, 3, 2> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x6565b3(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a56fe
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0x10, %r9
cmpq $0x10, %r9
je 0x3a56f3
incq %r8
addq $0x4, %rdi
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a56f0
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss (%r8,%r10), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0xc, %r10
jne 0x3a5731
movq %r9, %r10
shlq $0x4, %r10
movss %xmm0, (%rdi,%r10)
leaq 0x1(%r9), %r10
addq $0xc, %r8
testq %r9, %r9
movq %r10, %r9
je 0x3a572b
incq %rcx
addq $0x4, %rsi
cmpq $0x4, %rcx
jne 0x3a5721
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 4, 3> tcu::operator*<float, 4, 3, 3, 3>(tcu::Matrix<float, 4, 3> const&, tcu::Matrix<float, 3, 3> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x65650f(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a57a2
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r9)
addq $0x10, %r9
cmpq $0x30, %r9
jne 0x3a5797
incq %r8
addq $0x4, %rdi
addq $0x10, %rcx
cmpq $0x4, %r8
jne 0x3a5794
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss (%r8,%r10), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0xc, %r10
jne 0x3a57d5
movq %r9, %r10
shlq $0x4, %r10
movss %xmm0, (%rdi,%r10)
incq %r9
addq $0xc, %r8
cmpq $0x3, %r9
jne 0x3a57cf
incq %rcx
addq $0x4, %rsi
cmpq $0x4, %rcx
jne 0x3a57c5
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 4> tcu::operator+<float, 2, 4>(tcu::Matrix<float, 2, 4> const&, tcu::Matrix<float, 2, 4> const&)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) + b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x6563cd(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a58e4
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x4, %r9
jne 0x3a58d9
leaq 0x1(%rcx), %r9
addq $0x4, %r8
testq %rcx, %rcx
movq %r9, %rcx
je 0x3a58d6
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
addss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x1, %r8
je 0x3a5908
incq %rcx
addq $0x8, %rdi
addq $0x8, %rdx
addq $0x8, %rsi
cmpq $0x4, %rcx
jne 0x3a5905
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 4> tcu::operator-<float, 2, 4>(tcu::Matrix<float, 2, 4> const&, tcu::Matrix<float, 2, 4> const&)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) - b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x656350(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a5961
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x4, %r9
jne 0x3a5956
leaq 0x1(%rcx), %r9
addq $0x4, %r8
testq %rcx, %rcx
movq %r9, %rcx
je 0x3a5953
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
subss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x1, %r8
je 0x3a5985
incq %rcx
addq $0x8, %rdi
addq $0x8, %rdx
addq $0x8, %rsi
cmpq $0x4, %rcx
jne 0x3a5982
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 4> deqp::gles3::Functional::MatrixCaseUtils::matrixCompMult<float, 2, 4>(tcu::Matrix<float, 2, 4> const&, tcu::Matrix<float, 2, 4> const&)
|
tcu::Matrix<T, Rows, Cols> matrixCompMult (const tcu::Matrix<T, Rows, Cols>& a, const tcu::Matrix<T, Rows, Cols>& b)
{
tcu::Matrix<T, Rows, Cols> retVal;
for (int r = 0; r < Rows; ++r)
for (int c = 0; c < Cols; ++c)
retVal(r,c) = a(r,c) * b(r, c);
return retVal;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x656256(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
movaps %xmm0, %xmm1
cmpq %r9, %rcx
je 0x3a5a5b
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x4, %r9
jne 0x3a5a50
leaq 0x1(%rcx), %r9
addq $0x4, %r8
testq %rcx, %rcx
movq %r9, %rcx
je 0x3a5a4d
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,8), %xmm0
mulss (%rdx,%r8,8), %xmm0
movss %xmm0, (%rdi,%r8,8)
incq %r8
cmpq $0x4, %r8
jne 0x3a5a7f
leaq 0x1(%rcx), %r8
addq $0x4, %rsi
addq $0x4, %rdx
addq $0x4, %rdi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a5a7c
retq
|
/kaydenl[P]VK-GL-CTS/modules/gles3/functional/es3fShaderMatrixTests.cpp
|
tcu::Matrix<float, 2, 2> tcu::operator*<float, 2, 4, 4, 2>(tcu::Matrix<float, 2, 4> const&, tcu::Matrix<float, 4, 2> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x6561da(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a5ad4
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r8,8)
incq %r8
cmpq $0x1, %r8
je 0x3a5ac9
leaq 0x1(%rcx), %r8
addq $0x4, %rdi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a5ac6
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,8), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
incq %r10
cmpq $0x4, %r10
jne 0x3a5b05
movss %xmm0, (%rdi,%r9,8)
leaq 0x1(%r9), %r10
addq $0x10, %r8
testq %r9, %r9
movq %r10, %r9
je 0x3a5aff
leaq 0x1(%rcx), %rdi
addq $0x4, %rsi
testq %rcx, %rcx
movq %rdi, %rcx
je 0x3a5af5
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 3> tcu::operator*<float, 2, 4, 4, 3>(tcu::Matrix<float, 2, 4> const&, tcu::Matrix<float, 4, 3> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movss 0x656140(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a5b6e
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r8,8)
incq %r8
cmpq $0x3, %r8
jne 0x3a5b63
leaq 0x1(%rcx), %r8
addq $0x4, %rdi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a5b60
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,8), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
incq %r10
cmpq $0x4, %r10
jne 0x3a5b9f
movss %xmm0, (%rdi,%r9,8)
incq %r9
addq $0x10, %r8
cmpq $0x3, %r9
jne 0x3a5b99
leaq 0x1(%rcx), %rdi
addq $0x4, %rsi
testq %rcx, %rcx
movq %rdi, %rcx
je 0x3a5b8f
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 2, 4> tcu::operator*<float, 2, 4, 4, 4>(tcu::Matrix<float, 2, 4> const&, tcu::Matrix<float, 4, 4> const&)
|
Matrix<T, Rows0, Cols1> operator* (const Matrix<T, Rows0, Cols0>& a, const Matrix<T, Rows1, Cols1>& b)
{
DE_STATIC_ASSERT(Cols0 == Rows1);
Matrix<T, Rows0, Cols1> res;
for (int row = 0; row < Rows0; row++)
{
for (int col = 0; col < Cols1; col++)
{
T v = T(0);
for (int ndx = 0; ndx < Cols0; ndx++)
v += a(row,ndx) * b(ndx,col);
res(row,col) = v;
}
}
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x6560ad(%rip), %xmm0 # 0x9fbca0
xorl %r8d, %r8d
movaps %xmm0, %xmm1
cmpq %r8, %rcx
je 0x3a5c01
xorps %xmm1, %xmm1
movss %xmm1, (%rdi,%r8,8)
incq %r8
cmpq $0x4, %r8
jne 0x3a5bf6
leaq 0x1(%rcx), %r8
addq $0x4, %rdi
testq %rcx, %rcx
movq %r8, %rcx
je 0x3a5bf3
xorl %ecx, %ecx
leaq (%rax,%rcx,4), %rdi
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,8), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
incq %r10
cmpq $0x4, %r10
jne 0x3a5c32
movss %xmm0, (%rdi,%r9,8)
incq %r9
addq $0x10, %r8
cmpq $0x4, %r9
jne 0x3a5c2c
leaq 0x1(%rcx), %rdi
addq $0x4, %rsi
testq %rcx, %rcx
movq %rdi, %rcx
je 0x3a5c22
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 4> tcu::operator+<float, 3, 4>(tcu::Matrix<float, 3, 4> const&, tcu::Matrix<float, 3, 4> const&)
|
Matrix<T, Rows, Cols> operator+ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) + b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x656016(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a5c9e
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0xc, %r10
cmpq $0x30, %r10
jne 0x3a5c93
incq %r9
addq $0x4, %r8
addq $0xc, %rcx
cmpq $0x3, %r9
jne 0x3a5c90
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
addss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x3, %r8
jne 0x3a5cc4
incq %rcx
addq $0xc, %rdi
addq $0xc, %rdx
addq $0xc, %rsi
cmpq $0x4, %rcx
jne 0x3a5cc1
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 4> tcu::operator-<float, 3, 4>(tcu::Matrix<float, 3, 4> const&, tcu::Matrix<float, 3, 4> const&)
|
Matrix<T, Rows, Cols> operator- (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) - b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655f90(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a5d24
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0xc, %r10
cmpq $0x30, %r10
jne 0x3a5d19
incq %r9
addq $0x4, %r8
addq $0xc, %rcx
cmpq $0x3, %r9
jne 0x3a5d16
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
subss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x3, %r8
jne 0x3a5d4a
incq %rcx
addq $0xc, %rdi
addq $0xc, %rdx
addq $0xc, %rsi
cmpq $0x4, %rcx
jne 0x3a5d47
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
tcu::Matrix<float, 3, 4> tcu::operator/<float, 3, 4>(tcu::Matrix<float, 3, 4> const&, tcu::Matrix<float, 3, 4> const&)
|
Matrix<T, Rows, Cols> operator/ (const Matrix<T, Rows, Cols>& a, const Matrix<T, Rows, Cols>& b)
{
Matrix<T, Rows, Cols> res;
for (int col = 0; col < Cols; col++)
for (int row = 0; row < Rows; row++)
res(row, col) = a(row, col) / b(row, col);
return res;
}
|
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %ecx, %ecx
movss 0x655f0a(%rip), %xmm0 # 0x9fbca0
movq %rdi, %r8
xorl %r9d, %r9d
xorl %r10d, %r10d
movaps %xmm0, %xmm1
cmpq %r10, %rcx
je 0x3a5daa
xorps %xmm1, %xmm1
movss %xmm1, (%r8,%r10)
addq $0xc, %r10
cmpq $0x30, %r10
jne 0x3a5d9f
incq %r9
addq $0x4, %r8
addq $0xc, %rcx
cmpq $0x3, %r9
jne 0x3a5d9c
xorl %ecx, %ecx
xorl %r8d, %r8d
movss (%rsi,%r8,4), %xmm0
divss (%rdx,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
cmpq $0x3, %r8
jne 0x3a5dd0
incq %rcx
addq $0xc, %rdi
addq $0xc, %rdx
addq $0xc, %rsi
cmpq $0x4, %rcx
jne 0x3a5dcd
retq
|
/kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.