name string | code string | asm string | file string |
|---|---|---|---|
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
... | /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
... | /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>... | 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,... | /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>... | 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,... | /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>... | 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,... | /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>... | 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
x... | /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>... | 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
x... | /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>... | 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 %... | /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>... | 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 %... | /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)
... | /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>... | 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
x... | /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>... | 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... | /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>... | 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... | /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>... | 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... | /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>... | 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... | /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>... | 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... | /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>... | 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... | /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 0x39ad... | /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>... | 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 %xm... | /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>... | 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, %xmm... | /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>... | 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 %xm... | /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>... | 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... | /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>... | 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 %xm... | /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>... | 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
... | /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>... | 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 %xm... | /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);
typen... | 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 %r... | /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);
typen... | 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 %r... | /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);
typen... | 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 %r... | /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);
typen... | 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 %r... | /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);
typen... | 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 %... | /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);
typen... | 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 %... | /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);
typen... | 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,... | /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);
typen... | 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,... | /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);
typen... | 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,... | /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);
typen... | 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,... | /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);
typen... | 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
x... | /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);
typen... | 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
x... | /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);
typen... | 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
x... | /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);
typen... | 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
x... | /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);
typen... | 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... | /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);
typen... | 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... | /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 || colN... | 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... | /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,... | /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,... | /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,... | /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 ... | /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 ... | /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 ... | /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 ... | /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
... | /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
... | /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
... | /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 $0... | /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 $0... | /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
cmp... | /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
cmp... | /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
cmp... | /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
cmp... | /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
a... | /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
a... | /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
a... | /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... | /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... | /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... | /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... | /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... | /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... | /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... | /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, %r... | /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 +=... | 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
test... | /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 +=... | 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
t... | /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
i... | /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
i... | /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 +=... | 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, %... | /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 +=... | 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 0x3... | /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 +=... | 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 ... | /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 0x3a4... | /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 0x3a4... | /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 0x3a4... | /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 0x3a4... | /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 +=... | 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 $0... | /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 +=... | 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... | /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 +=... | 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... | /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 $... | /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 $... | /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 $... | /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... | /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... | /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
... | /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 +=... | 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 $0... | /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 +=... | 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... | /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
add... | /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
add... | /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
add... | /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 +=... | 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, ... | /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 +=... | 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
test... | /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 +=... | 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
t... | /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
c... | /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
c... | /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
c... | /kaydenl[P]VK-GL-CTS/framework/common/tcuMatrix.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.