name string | code string | asm string | file string |
|---|---|---|---|
deqp::gls::BuiltinPrecisionTests::Apply<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 2, 3>, tcu::Vector<float, 2>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doGetUsedFuncs(std::set<deqp::gls::BuiltinPrecisionTests::FuncBase const*, std::le... | void doGetUsedFuncs (FuncSet& dst) const
{
m_func.getUsedFuncs(dst);
m_args.a->getUsedFuncs(dst);
m_args.b->getUsedFuncs(dst);
m_args.c->getUsedFuncs(dst);
m_args.d->getUsedFuncs(dst);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx,... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::ApplyVar<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 2, 3>, tcu::Vector<float, 2>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doEvaluate(deqp::gls::BuiltinPrecisionTests::EvalContext const&) const | IVal doEvaluate (const EvalContext& ctx) const
{
const Variable<Arg0>& var0 = static_cast<const Variable<Arg0>&>(*this->m_args.a);
const Variable<Arg1>& var1 = static_cast<const Variable<Arg1>&>(*this->m_args.b);
const Variable<Arg2>& var2 = static_cast<const Variable<Arg2>&>(*this->m_args.c);
const Variab... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rax
movq 0x20(%rsi), %r12
movq 0x30(%rsi), %r13
movq 0x40(%rsi), %rcx
movq %rcx, (%rsp)
movq 0x30(%rdx), %rdi
movq %rax, %rsi
callq 0x6b6ac6
movq %rax, %rbp
movq 0x30... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Apply<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 2, 3>, tcu::Vector<float, 2>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doEvaluate(deqp::gls::BuiltinPrecisionTests::EvalContext const&) const | IVal doEvaluate (const EvalContext& ctx) const
{
return m_func.apply(ctx,
m_args.a->evaluate(ctx), m_args.b->evaluate(ctx),
m_args.c->evaluate(ctx), m_args.d->evaluate(ctx));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rsi
movq (%rsi), %rax
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq *0x20(%rax)
movq 0x20(%r12), %rsi
movq (%rsi), %rax
leaq 0x60(%rsp), %rbp
movq %rbp,... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::InOutFuncCase<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 2, 3>, tcu::Vector<float, 2>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::runTest() | void InOutFuncCase<Sig>::runTest (void)
{
const Inputs<In> inputs (generateInputs(getSamplings(),
m_ctx.floatFormat,
m_ctx.precision,
m_ctx.numRandoms,
m_rnd));
Variables<In, Out> variables;
variables.out0 = variable<Ret>("out0");
variables.out1 = variable<Arg1>("out... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0xa0(%rbx), %rdx
movl 0xf0(%rbx), %ecx
movq 0xf8(%rbx), %r8
leaq 0x150(%rbx), %r9
leaq 0x90(%rsp), %rdi
movq %rax, %rsi
callq 0x6b4b3b
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::PrecisionCase::testStatement<deqp::gls::BuiltinPrecisionTests::InTypes<tcu::Vector<float, 2>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>, deqp::gls::BuiltinPrecisionTests::OutTypes<tcu::Matrix<float, 2, 3... | void PrecisionCase::testStatement (const Variables<In, Out>& variables,
const Inputs<In>& inputs,
const Statement& stmt)
{
using namespace ShaderExecUtil;
typedef typename In::In0 In0;
typedef typename In::In1 In1;
typedef typename In::In2 In2;
typedef typename In::In3 In3;
typedef... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x518, %rsp # imm = 0x518
movq %rcx, 0x70(%rsp)
movq %rsi, (%rsp)
movq %rdi, %r12
movq (%rdx), %rbx
movq %rdx, 0xa0(%rsp)
movq 0x8(%rdx), %r13
movq %r13, %rsi
subq %rbx, %rsi
sarq $0x3, %rsi
leaq 0x2f8(%rsp), %rdi
movq %rsi, 0x68(%rsp)
c... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Functions::OuterProduct<2, 3>::doApply(deqp::gls::BuiltinPrecisionTests::EvalContext const&, deqp::gls::BuiltinPrecisionTests::Tuple4<tcu::Vector<tcu::Interval, 2> const&, tcu::Vector<tcu::Interval, 3> const&, deqp::gls::BuiltinPrecisionTests::Void const&, deqp::gls::BuiltinPrecisionTe... | IRet doApply (const EvalContext& ctx, const IArgs& iargs) const
{
IRet ret;
for (int row = 0; row < Rows; ++row)
{
for (int col = 0; col < Cols; ++col)
ret[col][row] = call<Mul>(ctx, iargs.a[row], iargs.b[col]);
}
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %rbp
callq 0x753a2e
xorl %eax, %eax
leaq 0xf(%rsp), %r14
movq %rbp, 0x10(%rsp)
movq %rax, 0x18(%rsp)
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
movq %rbp, 0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Func<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 2, 3>, tcu::Vector<float, 2>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doPrint(std::ostream&, std::vector<deqp::gls::BuiltinPrecisionTests::ExprBase const... | virtual void doPrint (ostream& os, const BaseArgExprs& args) const
{
os << getName() << "(";
if (isTypeValid<Arg0>())
os << *args[0];
if (isTypeValid<Arg1>())
os << ", " << *args[1];
if (isTypeValid<Arg2>())
os << ", " << *args[2];
if (isTypeValid<Arg3>())
os << ", " << *args[3];
os << ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rsi
movq (%rdi), %rax
movq %rsp, %r15
movq %r15, %rdi
callq *0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x325e70
leaq 0x2a70ba(%rip), %rsi # 0xa37242
movl $0x1, %edx
movq %rax, %rdi
callq 0x325e... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Func<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 2, 3>, tcu::Vector<float, 2>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doGetParamNames[abi:cxx11]() const | virtual const ParamNames& doGetParamNames (void) const
{
static ParamNames names ("a", "b", "c", "d");
return names;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movb 0x4e7242(%rip), %al # 0xc77480
testb %al, %al
je 0x79025a
leaq 0x4e71b7(%rip), %rax # 0xc77400
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4e721f(%rip), %rdi # 0xc77480
callq 0x325590
testl %eax, %e... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::PrecisionCase* deqp::gls::BuiltinPrecisionTests::createFuncCase<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 3, 3>, tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>(deqp::gls::BuiltinPrecisi... | PrecisionCase* createFuncCase (const Context& context,
const string& name,
const Func<Sig>& func)
{
switch (func.getOutParamIndex())
{
case -1:
return new FuncCase<Sig>(context, name, func);
case 1:
return new InOutFuncCase<Sig>(context, name, func);
default:
DE_FATAL("Impossible");... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdx), %rax
movq %rdx, %rdi
callq *0x28(%rax)
cmpl $0x1, %eax
je 0x790462
cmpl $-0x1, %eax
jne 0x790493
movl $0x188, %edi # imm = 0x188
callq 0x325210
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
m... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::FuncCase<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 3, 3>, tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::runTest() | void FuncCase<Sig>::runTest (void)
{
const Inputs<In> inputs (generateInputs(getSamplings(),
m_ctx.floatFormat,
m_ctx.precision,
m_ctx.numRandoms,
m_rnd));
Variables<In, Out> variables;
variables.out0 = variable<Ret>("out0");
variables.out1 = variable<Void>("out1");
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0xa0(%rbx), %rdx
movl 0xf0(%rbx), %ecx
movq 0xf8(%rbx), %r8
leaq 0x150(%rbx), %r9
leaq 0x90(%rsp), %rdi
movq %rax, %rsi
callq 0x6d6ddb
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::PrecisionCase::testStatement<deqp::gls::BuiltinPrecisionTests::InTypes<tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>, deqp::gls::BuiltinPrecisionTests::OutTypes<tcu::Matrix<float, 3, 3>, deqp::gls::Bui... | void PrecisionCase::testStatement (const Variables<In, Out>& variables,
const Inputs<In>& inputs,
const Statement& stmt)
{
using namespace ShaderExecUtil;
typedef typename In::In0 In0;
typedef typename In::In1 In1;
typedef typename In::In2 In2;
typedef typename In::In3 In3;
typedef... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4d8, %rsp # imm = 0x4D8
movq %rcx, 0x90(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdi, %rbx
movq (%rdx), %rcx
movq %rdx, 0x40(%rsp)
movq 0x8(%rdx), %r13
movq %r13, %rax
movq %rcx, 0x98(%rsp)
subq %rcx, %rax
sarq $0x2, %rax
movabsq $-0x55555555... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Apply<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 3, 3>, tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doPrintExpr(std::ostream&) const | void doPrintExpr (ostream& os) const
{
BaseArgExprs args;
args.push_back(m_args.a.get());
args.push_back(m_args.b.get());
args.push_back(m_args.c.get());
args.push_back(m_args.d.get());
m_func.print(os, args);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x6b128e
movq 0x20(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::Apply<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 3, 3>, tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doGetUsedFuncs(std::set<deqp::gls::BuiltinPrecisionTests::FuncBase const*, std::le... | void doGetUsedFuncs (FuncSet& dst) const
{
m_func.getUsedFuncs(dst);
m_args.a->getUsedFuncs(dst);
m_args.b->getUsedFuncs(dst);
m_args.c->getUsedFuncs(dst);
m_args.d->getUsedFuncs(dst);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
movq %rbx,... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::ApplyVar<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 3, 3>, tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::doEvaluate(deqp::gls::BuiltinPrecisionTests::EvalContext const&) const | IVal doEvaluate (const EvalContext& ctx) const
{
const Variable<Arg0>& var0 = static_cast<const Variable<Arg0>&>(*this->m_args.a);
const Variable<Arg1>& var1 = static_cast<const Variable<Arg1>&>(*this->m_args.b);
const Variable<Arg2>& var2 = static_cast<const Variable<Arg2>&>(*this->m_args.c);
const Variab... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r15
movq 0x10(%rsi), %rax
movq 0x20(%rsi), %r12
movq 0x30(%rsi), %r13
movq 0x40(%rsi), %rcx
movq %rcx, (%rsp)
movq 0x30(%rdx), %rdi
movq %rax, %rsi
callq 0x6bdea6
movq %rax, %rbp
movq 0x30... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::BuiltinPrecisionTests::InOutFuncCase<deqp::gls::BuiltinPrecisionTests::Signature<tcu::Matrix<float, 3, 3>, tcu::Vector<float, 3>, tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>>::runTest() | void InOutFuncCase<Sig>::runTest (void)
{
const Inputs<In> inputs (generateInputs(getSamplings(),
m_ctx.floatFormat,
m_ctx.precision,
m_ctx.numRandoms,
m_rnd));
Variables<In, Out> variables;
variables.out0 = variable<Ret>("out0");
variables.out1 = variable<Arg1>("out... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0xa0(%rbx), %rdx
movl 0xf0(%rbx), %ecx
movq 0xf8(%rbx), %r8
leaq 0x150(%rbx), %r9
leaq 0x90(%rsp), %rdi
movq %rax, %rsi
callq 0x6bbf2f
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
void deqp::gls::BuiltinPrecisionTests::PrecisionCase::testStatement<deqp::gls::BuiltinPrecisionTests::InTypes<tcu::Vector<float, 3>, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void, deqp::gls::BuiltinPrecisionTests::Void>, deqp::gls::BuiltinPrecisionTests::OutTypes<tcu::Matrix<float, 3, 3... | void PrecisionCase::testStatement (const Variables<In, Out>& variables,
const Inputs<In>& inputs,
const Statement& stmt)
{
using namespace ShaderExecUtil;
typedef typename In::In0 In0;
typedef typename In::In1 In1;
typedef typename In::In2 In2;
typedef typename In::In3 In3;
typedef... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x528, %rsp # imm = 0x528
movq %rcx, 0x48(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movq (%rdx), %rbx
movq %rdx, 0xc8(%rsp)
movq 0x8(%rdx), %r12
movq %r12, %rax
subq %rbx, %rax
sarq $0x2, %rax
movabsq $-0x5555555555555555, %rsi # imm = ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsBuiltinPrecisionTests.cpp |
deqp::gls::MemObjectAllocator::allocUntilFailure() | bool MemObjectAllocator::allocUntilFailure (void)
{
de::Random rnd(m_seed);
GLU_CHECK_MSG("Error in init");
try
{
const deUint64 timeoutUs = 10000000; // 10s
deUint64 beginTimeUs = deGetMicroseconds();
deUint64 currentTimeUs;
do
{
GLU_CHECK_MSG("Unkown Error");
switch (m_objectTypes)
{
cas... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x30(%rdi), %esi
leaq 0x8(%rsp), %rdi
callq 0x9fa2bc
callq 0x95892c
leaq 0x26940c(%rip), %rsi # 0xa80b6e
leaq 0x268cee(%rip), %rdx # 0xa80457
movl %eax, %edi
movl $0x1f1, %ecx # imm = 0x1F1
callq 0x8... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsMemoryStressCase.cpp |
deqp::gls::MemObjectAllocator::allocateBuffer(de::Random&) | void MemObjectAllocator::allocateBuffer (de::Random& rnd)
{
const int vectorBlockSize = 128;
deUint32 buffer = 0;
deUint32 error = 0;
int size = rnd.getInt(m_config.minBufferSize, m_config.maxBufferSize);
glGenBuffers(1, &buffer);
error = glGetError();
if (error != 0)
{
m_result = RESULT_GEN_BUFFERS_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x4(%rsp)
movl 0x44(%rdi), %r14d
movl 0x48(%rdi), %r15d
leal -0x80000000(%r14), %r12d
movl %r15d, %r13d
xorl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
movq %rsi, %rdi
callq 0x9fa2ea
movl %eax, %ebp
orl %r12d, %r13d
... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsMemoryStressCase.cpp |
deqp::gls::MemoryStressCase::MemoryStressCase(tcu::TestContext&, glu::RenderContext&, unsigned int, int, int, int, int, bool, bool, bool, bool, char const*, char const*) | MemoryStressCase::MemoryStressCase (tcu::TestContext& ctx, glu::RenderContext& renderContext, deUint32 objectTypes, int minTextureSize, int maxTextureSize, int minBufferSize, int maxBufferSize, bool write, bool use, bool useDummyData, bool clearAfterOOM, const char* name, const char* desc)
: tcu::TestCase (ctx, na... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, %r13
movq %rdi, %rbx
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
callq 0x9a9abc
leaq 0x43ceb6(%rip), %rax # 0xc54bd8
movq %rax, (%rbx)
movabsq $0x500000000, %rax # imm = 0x50... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsMemoryStressCase.cpp |
deqp::gls::MemoryStressCase::iterate() | tcu::TestCase::IterateResult MemoryStressCase::iterate (void)
{
bool end = false;
tcu::TestLog& log = m_testCtx.getLog();
MemObjectAllocator allocator(log, m_renderCtx, m_objectTypes, m_config, deStringHash(getName()));
if (!allocator.allocUntilFailure())
{
// Allocation timed out
allocator.clearObjects(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r14
movq 0xb0(%rdi), %r15
movl 0x90(%rdi), %ebp
leaq 0x94(%rdi), %r12
movq 0x10(%rdi), %rdi
callq 0x9fa3f8
leaq 0x190(%rsp), %r13
movq %r13, %rdi
movq %r14,... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsMemoryStressCase.cpp |
deqp::gls::RandomShaderCase::deinit() | void RandomShaderCase::deinit (void)
{
delete m_tex2D;
delete m_texCube;
m_tex2D = DE_NULL;
m_texCube = DE_NULL;
// Free up memory
m_vertexArrays.clear();
m_indices.clear();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4c0(%rdi), %rdi
testq %rdi, %rdi
je 0x819828
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x4c0(%rbx), %r15
movq 0x4c8(%rbx), %r14
testq %r14, %r14
je 0x819850
movq %r14, %rdi
callq 0x8c02e6
movl $0x180, %esi # imm = 0x180
movq %r14, %rdi
callq 0x3251a0
leaq... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsRandomShaderCase.cpp |
tcu::Format::Enum<int, 1ul>::toStream(std::ostream&) const | std::ostream& toStream (std::ostream& stream) const
{
const char* name = m_getName(m_value);
if (name)
return stream << name;
else
return stream << Hex<NumBytes*2>((deUint64)m_value);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl 0x8(%rdi), %edi
callq *(%r15)
testq %rax, %rax
je 0x831429
movq %rax, %r14
movq %rax, %rdi
callq 0x325680
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x325e70
jmp 0x831440
movslq 0x8(%r15), %rax
leaq 0x8(%rsp), %rdi
movq %r... | /kaydenl[P]VK-GL-CTS/framework/common/tcuFormatUtil.hpp |
std::ostream& tcu::Format::operator<<<unsigned int const*>(std::ostream&, tcu::Format::Array<unsigned int const*> const&) | std::ostream& operator<< (std::ostream& str, const Array<Iterator>& fmt)
{
str << "{ ";
for (Iterator cur = fmt.begin; cur != fmt.end; ++cur)
{
if (cur != fmt.begin)
str << ", ";
str << *cur;
}
str << " }";
return str;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1ce0f6(%rip), %rsi # 0x9ff5d5
movl $0x2, %edx
callq 0x325e70
movq (%r14), %r12
cmpq 0x8(%r14), %r12
je 0x831524
leaq 0x2552a2(%rip), %r15 # 0xa8679b
cmpq (%r14), %r12
je 0x83150e
movl $0x2, %edx
movq %rbx, %rdi
movq %r15... | /kaydenl[P]VK-GL-CTS/framework/common/tcuFormatUtil.hpp |
std::ostream& tcu::Format::operator<<<long const*>(std::ostream&, tcu::Format::Array<long const*> const&) | std::ostream& operator<< (std::ostream& str, const Array<Iterator>& fmt)
{
str << "{ ";
for (Iterator cur = fmt.begin; cur != fmt.end; ++cur)
{
if (cur != fmt.begin)
str << ", ";
str << *cur;
}
str << " }";
return str;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1cdff7(%rip), %rsi # 0x9ff5d5
movl $0x2, %edx
callq 0x325e70
movq (%r14), %r12
cmpq 0x8(%r14), %r12
je 0x831623
leaq 0x2551a3(%rip), %r15 # 0xa8679b
cmpq (%r14), %r12
je 0x83160d
movl $0x2, %edx
movq %rbx, %rdi
movq %r15... | /kaydenl[P]VK-GL-CTS/framework/common/tcuFormatUtil.hpp |
deqp::gls::Functional::ScissorTestInternal::createClearTest(tcu::TestContext&, glu::RenderContext&, char const*, char const*, tcu::Vector<float, 4> const&, unsigned int) | tcu::TestNode* createClearTest (tcu::TestContext& testCtx,
glu::RenderContext& renderCtx,
const char* name,
const char* desc,
const Vec4& scissorArea,
deUint32 clearMode)
{
return new ScissorClearCase(testCtx, renderCtx, name, desc, scissorArea, clearMode);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
movl $0x90, %edi
callq 0x325210
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x9a9abc
leaq 0x423b5c(%r... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsScissorTests.cpp |
deqp::gls::Functional::(anonymous namespace)::ScissorCase::iterate() | ScissorCase::IterateResult ScissorCase::iterate (void)
{
using TextureTestUtil::RandomViewport;
const glw::Functions& gl = m_renderCtx.getFunctions();
TestLog& log = m_testCtx.getLog();
const tcu::PixelFormat renderFormat = m_renderCtx.getRenderTarget().getPixelFormat();
const tcu::Vec4 threshold ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp # imm = 0x308
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x70(%rbx), %rdi
movq 0x10(%rax), %r14
movq (%rdi), %rax
callq *0x20(%rax)
movl $0x8, %ecx
subl... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsScissorTests.cpp |
void deqp::gls::Functional::(anonymous namespace)::clearEdges<tcu::Vector<int, 4>>(tcu::PixelBufferAccess const&, tcu::Vector<int, 4> const&, tcu::Vector<int, 4> const&) | void clearEdges (const tcu::PixelBufferAccess& access, const T& color, const IVec4& scissorArea)
{
for (int y = 0; y < access.getHeight(); y++)
for (int x = 0; x < access.getWidth(); x++)
{
if (y < scissorArea.y() ||
y >= scissorArea.y() + scissorArea.w() ||
x < scissorArea.x() ||
x >= scissorArea.x()+ sc... | cmpl $0x0, 0xc(%rdi)
jle 0x832b4c
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
cmpl $0x0, 0x8(%r15)
jle 0x832b3c
xorl %r12d, %r12d
movl 0x4(%rbx), %eax
cmpl %eax, %ebp
jl 0x832b20
addl 0xc(%rbx), %eax
cmpl %eax, %ebp
jge 0x832b20
movl (%rbx), %ea... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsScissorTests.cpp |
deqp::gls::Functional::(anonymous namespace)::ScissorClearCase::render(unsigned int, tcu::Vector<int, 4> const&) const | void ScissorClearCase::render (GLuint program, const IVec4&) const
{
const glw::Functions& gl = m_renderCtx.getFunctions();
const Vec4 white (1.0f, 1.0f, 1.0f, 1.0);
gl.clearColor(0.6f, 0.1f, 0.1f, 1.0);
gl.clearDepthf(0.0f);
if (m_clearMode & GL_DEPTH_BUFFER_BIT)
{
gl.enable(GL_DEPTH_TEST);
gl.depthFun... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq 0x70(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rbx
movaps 0x1cdf31(%rip), %xmm0 # 0xa00c70
movups %xmm0, (%rsp)
movss 0x1ce555(%rip), %xmm0 # 0xa012a0
movss 0x1cfbb1(%rip), %xmm1 # 0xa02904
movss 0x... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsScissorTests.cpp |
deqp::gls::Functional::(anonymous namespace)::drawQuad(glw::Functions const&, unsigned int, tcu::Vector<float, 3> const&, tcu::Vector<float, 3> const&) | void drawQuad (const glw::Functions& gl, deUint32 program, const Vec3& p0, const Vec3& p1)
{
// Vertex data.
const float hz = (p0.z() + p1.z()) * 0.5f;
const float position[] =
{
p0.x(), p0.y(), p0.z(), 1.0f,
p0.x(), p1.y(), hz, 1.0f,
p1.x(), p0.y(), hz, 1.0f,
p1.x(), p1.y(), p1.z(), 1.0f
};
const deUi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movss 0x8(%rdx), %xmm0
movss 0x8(%rcx), %xmm1
movss (%rdx), %xmm2
leaq 0x10(%rsp), %r14
movss %xmm2, (%r14)
movss 0x4(%rdx), %xmm3
movss %xmm3, 0x4(%r14)
movss %xmm0, 0x8(%r14)
addss %xmm1, %xmm0
mulss 0x1c8dca(%rip)... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsScissorTests.cpp |
deqp::gls::Functional::(anonymous namespace)::FramebufferClearCase::render(unsigned int) const | void FramebufferClearCase::render (GLuint program) const
{
const glw::Functions& gl = m_renderCtx.getFunctions();
const BufferFmtDesc bufferFmt = getBufferFormat(m_clearType);
const Color clearColor = getMainColor(bufferFmt);
const int clearStencil = 123;
const float clearDepth = 0.5f;
swi... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r15
movq 0x70(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x78(%r15), %edx
movl %edx, %ecx
shll $0x4, %ecx
movabsq $-0x7283727177e57fa8, %rsi # imm = 0x8D7C8D8E881A8058
shrq %cl, %rsi
movq %rax, %r14
cmpl $0x4, %edx
movl $... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsScissorTests.cpp |
deqp::gls::Functional::(anonymous namespace)::FramebufferBlitCase::init() | void FramebufferBlitCase::init (void)
{
if (m_renderCtx.getRenderTarget().getNumSamples())
throw tcu::NotSupportedError("Cannot blit to multisampled framebuffer", "", __FILE__, __LINE__);
const glw::Functions& gl = m_renderCtx.getFunctions();
const glu::Renderbuffer colorbuf (gl);
const tcu::Vec4 clearColor ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x0, 0x20(%rax)
jne 0x833de1
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
movl $0x2, %edi
callq 0x92b7be
movq %rsp, %rdi
movq %r14, %rsi
movq %rax, %r... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsScissorTests.cpp |
deqp::gls::TextureStateQueryTests::isLegalTesterForTarget(unsigned int, deqp::gls::TextureStateQueryTests::TesterType) | bool isLegalTesterForTarget (glw::GLenum target, TesterType tester)
{
// no 3d filtering on 2d targets
if ((tester == TESTER_TEXTURE_WRAP_R || tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER) && target != GL_TEXTURE_3D)
return false;
// no sampling on multisample
if (isMultisampleTarget(target) && isSamplerStat... | cmpl $0x12, %esi
sete %al
cmpl $0x38, %esi
sete %cl
cmpl $0x806f, %edi # imm = 0x806F
je 0x833f6b
orb %cl, %al
je 0x833f6b
xorl %eax, %eax
retq
movl %edi, %eax
andl $-0x3, %eax
cmpl $0x9100, %eax # imm = 0x9100
jne 0x833f8f
addl $-0xc, %esi
cmpl $0x2d, %esi
jae 0x833f8f
movabsq $0x1e4048049249, %rax... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::isSamplerStateTester(deqp::gls::TextureStateQueryTests::TesterType) | bool isSamplerStateTester (TesterType tester)
{
return tester == TESTER_TEXTURE_WRAP_S ||
tester == TESTER_TEXTURE_WRAP_T ||
tester == TESTER_TEXTURE_WRAP_R ||
tester == TESTER_TEXTURE_MAG_FILTER ||
tester == TESTER_TEXTURE_MIN_FILTER ||
tester == TESTER_TEXTURE_MIN_LOD ||
tester... | movl %edi, %ecx
cmpl $0x39, %edi
setb %dl
movabsq $0x1e4048049249000, %rax # imm = 0x1E4048049249000
shrq %cl, %rax
andb %dl, %al
retq
| /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::createIsTextureTest(tcu::TestContext&, glu::RenderContext const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int) | tcu::TestCase* createIsTextureTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, glw::GLenum target)
{
return new IsTextureCase(testCtx, renderCtx, name.c_str(), description.c_str(), target);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
movl $0x80, %edi
callq 0x325210
movq %rax, %r14
movq (%r13), %rdx
movq (%r12), %rcx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x9a9abc
leaq 0x4213f9(%rip), %rax # 0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::TextureCompareFuncCase::TextureCompareFuncCase(tcu::TestContext&, glu::RenderContext const&, char const*, char const*, unsigned int, deqp::gls::TextureStateQueryTests::TesterType, deqp::gls::StateQueryUtil::QueryType) | TextureCompareFuncCase::TextureCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
: TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl 0x38(%rsp), %r12d
movl 0x30(%rsp), %ebp
movq %rcx, %rdx
movq %r8, %rcx
callq 0x9a9abc
leaq 0x420f36(%rip), %rax # 0xc554b8
movq %rax, (%r15)
movq %r14, 0x70(%r15)
movl %ebx, 0x78(%r15)
movl %ebp, %edi
callq 0x... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::DepthStencilModeCase::DepthStencilModeCase(tcu::TestContext&, glu::RenderContext const&, char const*, char const*, unsigned int, deqp::gls::TextureStateQueryTests::TesterType, deqp::gls::StateQueryUtil::QueryType) | DepthStencilModeCase::DepthStencilModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
: TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl 0x38(%rsp), %r12d
movl 0x30(%rsp), %ebp
movq %rcx, %rdx
movq %r8, %rcx
callq 0x9a9abc
leaq 0x420e6e(%rip), %rax # 0xc554b8
movq %rax, (%r15)
movq %r14, 0x70(%r15)
movl %ebx, 0x78(%r15)
movl %ebp, %edi
callq 0x... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::IsTextureCase::init() | void IsTextureCase::init (void)
{
const de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(m_renderCtx));
RequiredExtensions extensions;
// target
if (!isCoreTextureTarget(m_renderCtx.getType(), m_target))
extensions.add(getTextureTargetExtension(m_renderCtx.getType(), m_target));
extensio... | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq 0x70(%rdi), %rdi
callq 0x8b5bb6
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x70(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x18(%rsp), %rdi
movl %eax, (%rdi)
movl 0x78(%r14), %esi
callq 0x835266
testb %al, %al
... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::isCoreTextureTarget(glu::ContextType const&, unsigned int) | static bool isCoreTextureTarget (const glu::ContextType& contextType, glw::GLenum target)
{
if (contextSupports(contextType, glu::ApiType::es(3,2)))
return es32::isCoreTextureTarget(target);
else if (contextSupports(contextType, glu::ApiType::es(3,1)))
return es31::isCoreTextureTarget(target);
else if (contextSu... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edi
movl $0x23, %esi
callq 0x8b85e8
testb %al, %al
je 0x83529b
movb $0x1, %al
cmpl $0x8512, %ebx # imm = 0x8512
jg 0x8352cc
cmpl $0xde1, %ebx # imm = 0xDE1
je 0x8352de
cmpl $0x806f, %ebx # imm = 0x806F
je 0x835... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::RequiredExtensions::check(glu::ContextInfo const&) const | static bool isPureIntTester (TesterType tester)
{
#define HANDLE_ALL_SETTERS(X) \
case X: \
case X ## _SET_PURE_UINT: return false; \
case X ## _SET_PURE_INT: return true;
switch (tester)
{
HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
HANDLE_ALL_SETTERS(TESTER... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x8354db
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::RequiredExtensions::RequiredExtensions(char const*) | explicit RequiredExtensions (const char* ext) { add(ext); } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x835678
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x835753
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3251a0
movq %r14, %rdi
callq 0x3259a0
nop
| /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::TextureTest::iterate() | TextureTest::IterateResult TextureTest::iterate (void)
{
glu::CallLogWrapper gl (m_renderCtx.getFunctions(), m_testCtx.getLog());
tcu::ResultCollector result (m_testCtx.getLog(), " // ERROR: ");
gl.enableLogging(true);
test(gl, result);
result.setTestContextResult(m_testCtx);
return STOP;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rdx
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x8e03bc
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x20428... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::isCoreTextureParam(glu::ContextType const&, unsigned int) | static bool isCoreTextureParam (const glu::ContextType& contextType, glw::GLenum pname)
{
if (contextSupports(contextType, glu::ApiType::es(3,2)))
return es32::isCoreTextureParam(pname);
else if (contextSupports(contextType, glu::ApiType::es(3,1)))
return es31::isCoreTextureParam(pname);
else if (contextSupports... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edi
movl $0x23, %esi
callq 0x8b85e8
testb %al, %al
je 0x836923
movl %ebx, %edi
callq 0x836c79
cmpl $0x90ea, %ebx # imm = 0x90EA
sete %cl
orb %al, %cl
cmpl $0x1004, %ebx # imm = 0x1004
jmp 0x836943
movl (%r14), %edi
movl $... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::isCoreQuery(glu::ContextType const&, deqp::gls::StateQueryUtil::QueryType) | static bool isCoreQuery (const glu::ContextType& contextType, QueryType query)
{
if (contextSupports(contextType, glu::ApiType::es(3,2)))
return es32::isCoreQuery(query);
else if (contextSupports(contextType, glu::ApiType::es(3,1)))
return es31::isCoreQuery(query);
else if (contextSupports(contextType, glu::ApiT... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edi
movl $0x23, %esi
callq 0x8b85e8
testb %al, %al
je 0x836a17
cmpl $0x2a, %ebx
jae 0x836a2d
movabsq $0x3fc1fe00000, %rax # imm = 0x3FC1FE00000
jmp 0x836a52
movl (%r14), %edi
movl $0x13, %esi
callq 0x8b85e8
testb %al, %al
je 0x836a31
cmpl... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::getQueryExtension(glu::ContextType const&, deqp::gls::StateQueryUtil::QueryType) | static RequiredExtensions getQueryExtension (const glu::ContextType& contextType, QueryType query)
{
DE_ASSERT(!isCoreQuery(contextType, query));
if (contextSupports(contextType, glu::ApiType::es(3,2)))
return es32::getQueryExtension(query);
else if (contextSupports(contextType, glu::ApiType::es(3,1)))
return e... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edi
movl $0x23, %esi
callq 0x8b85e8
testb %al, %al
jne 0x836ac3
movl (%r14), %edi
movl $0x13, %esi
callq 0x8b85e8
testb %al, %al
je 0x836ab6
cmpl $0x29, %ebp
ja 0x836ac3
movl %ebp, %eax
movabsq $0x33019800000, %rcx # imm =... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::isCoreTester(glu::ContextType const&, deqp::gls::TextureStateQueryTests::TesterType) | static bool isCoreTester (const glu::ContextType& contextType, TesterType tester)
{
if (contextSupports(contextType, glu::ApiType::es(3,2)))
return es32::isCoreTester(tester);
else if (contextSupports(contextType, glu::ApiType::es(3,1)))
return es31::isCoreTester(tester);
else if (contextSupports(contextType, gl... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edi
movl $0x23, %esi
callq 0x8b85e8
testb %al, %al
je 0x836b24
cmpl $0x2f, %ebx
setb %dl
movabsq $0x649249249249, %rsi # imm = 0x649249249249
movl %ebx, %ecx
shrq %cl, %rsi
movb $0x1, %al
cmpl $0x2f, %ebx
je 0x836b7d
andb %sil, %dl
jne 0x8... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::getTesterExtension(glu::ContextType const&, deqp::gls::TextureStateQueryTests::TesterType) | static RequiredExtensions getTesterExtension (const glu::ContextType& contextType, TesterType tester)
{
DE_ASSERT(!isCoreTester(contextType, tester));
if (contextSupports(contextType, glu::ApiType::es(3,2)))
return es32::getTesterExtension(tester);
else if (contextSupports(contextType, glu::ApiType::es(3,1)))
r... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edi
movl $0x23, %esi
callq 0x8b85e8
testb %al, %al
je 0x836bb4
addl $-0x32, %ebp
cmpl $0x2, %ebp
ja 0x836bfa
leaq 0x24cd48(%rip), %rsi # 0xa838fa
jmp 0x836be3
movl (%r14), %edi
movl $0x13, %esi
callq 0x8b85e8
testb %al, %a... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::es30::isCoreTextureParam(unsigned int) | static bool isCoreTextureParam (glw::GLenum pname)
{
return pname == GL_TEXTURE_BASE_LEVEL ||
pname == GL_TEXTURE_COMPARE_MODE ||
pname == GL_TEXTURE_COMPARE_FUNC ||
pname == GL_TEXTURE_MAG_FILTER ||
pname == GL_TEXTURE_MAX_LEVEL ||
pname == GL_TEXTURE_MAX_LOD ||
pname == GL_TEXTURE_MIN_FI... | movb $0x1, %al
cmpl $0x82de, %edi # imm = 0x82DE
jg 0x836c9a
leal -0x2800(%rdi), %ecx
cmpl $0x4, %ecx
jb 0x836c99
leal -0x813a(%rdi), %ecx
cmpl $0x4, %ecx
jae 0x836ccc
retq
cmpl $0x8e41, %edi # imm = 0x8E41
jle 0x836cb7
leal -0x8e42(%rdi), %ecx
cmpl $0x4, %ecx
jb 0x836c99
cmpl $0x912f, %edi ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::isPureIntTester(deqp::gls::TextureStateQueryTests::TesterType) | static bool isPureIntTester (TesterType tester)
{
#define HANDLE_ALL_SETTERS(X) \
case X: \
case X ## _SET_PURE_UINT: return false; \
case X ## _SET_PURE_INT: return true;
switch (tester)
{
HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
HANDLE_ALL_SETTERS(TESTER... | movl %edi, %ecx
cmpl $0x34, %edi
setb %dl
movabsq $0x9092492492492, %rax # imm = 0x9092492492492
shrq %cl, %rax
andb %dl, %al
retq
| /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::isPureUintTester(deqp::gls::TextureStateQueryTests::TesterType) | static bool isPureUintTester (TesterType tester)
{
#define HANDLE_ALL_SETTERS(X) \
case X: \
case X ## _SET_PURE_INT: return false; \
case X ## _SET_PURE_UINT: return true;
switch (tester)
{
HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
HANDLE_ALL_SETTERS(TESTE... | movl %edi, %ecx
cmpl $0x35, %edi
setb %dl
movabsq $0x12124924924924, %rax # imm = 0x12124924924924
shrq %cl, %rax
andb %dl, %al
retq
nop
| /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::TextureWrapCase::test(glu::CallLogWrapper&, tcu::ResultCollector&) const | void TextureWrapCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
{
const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
if (!isPureCase)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
verifyStateTextureParamInteger(result, gl,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x80(%rdi), %r12d
movl %r12d, %edi
callq 0x836cd7
movb $0x1, %bpl
testb %al, %al
jne 0x836d5a
movl %r12d, %edi
callq 0x836cef
movl %eax, %ebp
testb %bpl, %bpl
jne 0x836e21
movq 0x8(%r1... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::TextureFilterCase::test(glu::CallLogWrapper&, tcu::ResultCollector&) const | void TextureFilterCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
{
const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
const glw::GLenum initial = (m_pname == GL_TEXTURE_MAG_FILTER) ? (GL_LINEAR)
: (m_pname == GL_TEXTURE_MIN_FILTER) ? (GL_NEAREST_MIPM... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x80(%rdi), %r12d
movl %r12d, %edi
callq 0x836cd7
movb $0x1, %r13b
testb %al, %al
jne 0x837b55
movl %r12d, %edi
callq 0x836cef
movl %eax, %r13d
movl 0x7c(%r15), %eax
xorl %ecx, %ecx
cm... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::TextureLODCase::test(glu::CallLogWrapper&, tcu::ResultCollector&) const | void TextureLODCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
{
const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
const int initialValue = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000)
: (m_pname == GL_TEXTURE_MAX_LOD) ? (1000)
: (-1);
if ((query... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x80(%rdi), %r12d
movl %r12d, %edi
callq 0x836cd7
movb $0x1, %bpl
testb %al, %al
jne 0x838bfe
movl %r12d, %edi
callq 0x836cef
movl %eax, %ebp
movl 0x7c(%r15), %ecx
movl 0x84(%r15), %ed... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::TextureStateQueryTests::(anonymous namespace)::TextureCompareModeCase::test(glu::CallLogWrapper&, tcu::ResultCollector&) const | void TextureCompareModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
{
const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
if (!isPureCase)
{
const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
verifyStateTextureParamInteger(resu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x80(%rdi), %r12d
movl %r12d, %edi
callq 0x836cd7
movb $0x1, %bpl
testb %al, %al
jne 0x83b252
movl %r12d, %edi
callq 0x836cef
movl %eax, %ebp
testb %bpl, %bpl
jne 0x83b316
movq 0x8(%r1... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsTextureStateQueryTests.cpp |
deqp::gls::ub::ShaderInterface::findStruct(char const*) const | const StructType* ShaderInterface::findStruct (const char* name) const
{
std::vector<StructType*>::const_iterator pos = std::find_if(m_structs.begin(), m_structs.end(), StructNameEquals(name));
return pos != m_structs.end() ? *pos : DE_NULL;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0x333da2
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x857567
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %r... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsUniformBlockCase.cpp |
deqp::gls::UniformBlockCase::checkLayoutIndices(deqp::gls::ub::UniformLayout const&) const | bool UniformBlockCase::checkLayoutIndices (const UniformLayout& layout) const
{
TestLog& log = m_testCtx.getLog();
int numUniforms = (int)layout.uniforms.size();
int numBlocks = (int)layout.blocks.size();
bool isOk = true;
// Check uniform block indices.
for (int uniformNdx = 0; uniformNdx < numUniforms;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq 0x8(%rdi), %rax
movq 0x10(%rax), %r13
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rbp
subq 0x18(%rsi), %rbp
shrq $0x6, %rbp
movq %rsi, 0x10(%rsp)
subq (%rsi), %rax
shrq $0x6, %rax
movq %rax, 0x8(%rsp)
testl %ebp... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsUniformBlockCase.cpp |
deqp::gls::UniformBlockCase::checkIndexQueries(unsigned int, deqp::gls::ub::UniformLayout const&) const | bool UniformBlockCase::checkIndexQueries (deUint32 program, const UniformLayout& layout) const
{
tcu::TestLog& log = m_testCtx.getLog();
const glw::Functions& gl = m_renderCtx.getFunctions();
bool allOk = true;
// \note Spec mandates that uniform blocks are assigned consecutive locations from 0
// ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %r15
movl %esi, 0x4(%rsp)
movq 0x8(%rdi), %rax
movq 0x70(%rdi), %rdi
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
movq (%r15), %rbx
movq %r15, 0x10(%r... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsUniformBlockCase.cpp |
deqp::gls::UniformBlockCase::render(unsigned int) const | bool UniformBlockCase::render (deUint32 program) const
{
tcu::TestLog& log = m_testCtx.getLog();
const glw::Functions& gl = m_renderCtx.getFunctions();
de::Random rnd (deStringHash(getName()));
const tcu::RenderTarget& renderTarget = m_renderCtx.getRenderTarget();
const int viewportW = de::mi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movl %esi, 0x2c(%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x70(%rdi), %rdi
movq 0x10(%rax), %rax
movq %rax, 0x60(%rsp)
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x9fa3... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsUniformBlockCase.cpp |
deqp::gls::ub::(anonymous namespace)::computeStd140BaseAlignment(deqp::gls::ub::VarType const&) | int computeStd140BaseAlignment (const VarType& type)
{
const int vec4Alignment = (int)sizeof(deUint32)*4;
if (type.isBasicType())
{
glu::DataType basicType = type.getBasicType();
if (glu::isDataTypeMatrix(basicType))
{
bool isRowMajor = !!(type.getFlags() & LAYOUT_ROW_MAJOR);
int vecSize = isRowMajor... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x854e40
testl %eax, %eax
jne 0x854e60
movl 0x8(%rbx), %edi
leal -0x5(%rdi), %eax
cmpl $0x9, %eax
setae %al
leal -0x12(%rdi), %ecx
cmpl $0x9, %ecx
setae %cl
testb %cl, %al
jne 0x854e96
testb $0x40, 0x4(%rbx)
jne 0x854eaf
callq 0x8bb89... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsUniformBlockCase.cpp |
deqp::gls::ub::(anonymous namespace)::generateDeclaration(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, deqp::gls::ub::VarType const&, char const*, int, unsigned int) | void generateDeclaration (std::ostringstream& src, const VarType& type, const char* name, int indentLevel, deUint32 unusedHints)
{
deUint32 flags = type.getFlags();
if ((flags & LAYOUT_MASK) != 0)
src << "layout(" << LayoutFlagsFmt(flags & LAYOUT_MASK) << ") ";
if ((flags & PRECISION_MASK) != 0)
src << Precisi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %r14d
movl %ecx, %r12d
movq %rdx, 0x30(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rsi), %ebp
movl %ebp, %r13d
andl $0xf8, %r13d
je 0x8560a6
leaq 0x22e8b9(%rip), %rsi # 0xa8492e
movl $0x7, %edx
movq %rbx, %rdi
callq 0x3... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsUniformBlockCase.cpp |
deqp::gls::Array::usageTypeToString[abi:cxx11](deqp::gls::Array::Usage) | std::string Array::usageTypeToString(Usage usage)
{
static const char* usages[] =
{
"dynamic_draw", // USAGE_DYNAMIC_DRAW = 0,
"static_draw", // USAGE_STATIC_DRAW,
"stream_draw", // USAGE_STREAM_DRAW,
"stream_read", // USAGE_STREAM_READ,
"stream_copy", // USAGE_STREAM_COPY,
"static_read", // USAGE_STATI... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq %esi, %rax
leaq 0x3fcb12(%rip), %rcx # 0xc55d20
movq (%rcx,%rax,8), %rsi
leaq 0xf(%rsp), %rdx
callq 0x333da2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
| /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
deqp::gls::ContextArray::data(deqp::gls::Array::Target, int, char const*, deqp::gls::Array::Usage) | void ContextArray::data (Target target, int size, const char* ptr, Usage usage)
{
m_size = size;
m_target = target;
if (m_storage == STORAGE_BUFFER)
{
m_ctx.bindBuffer(targetToGL(target), m_glBuffer);
GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");
m_ctx.bufferData(targetToGL(target), size, ptr, us... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movl %edx, 0x24(%rdi)
movl %esi, 0x34(%rdi)
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x859495
cmpl $0x1, %eax
jne 0x8594ce
movl %r8d, %r15d
movq 0x10(%r14), %rdi
movslq %esi, %rax
leaq 0x22c606(%... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
deqp::gls::ContextArray::subdata(deqp::gls::Array::Target, int, int, char const*) | void ContextArray::subdata (Target target, int offset, int size, const char* ptr)
{
m_target = target;
if (m_storage == STORAGE_BUFFER)
{
m_ctx.bindBuffer(targetToGL(target), m_glBuffer);
GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");
m_ctx.bufferSubData(targetToGL(target), offset, size, ptr);
GL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rdi, %r14
movl %esi, 0x34(%rdi)
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x8595bd
cmpl $0x1, %eax
jne 0x8595dd
movq 0x10(%r14), %rdi
movslq %esi, %rax
leaq 0x22c4d3(%rip), %rcx # 0xa85a0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
deqp::gls::ContextArray::glBind(unsigned int) | void ContextArray::glBind (deUint32 loc)
{
if (m_storage == STORAGE_BUFFER)
{
m_ctx.bindBuffer(targetToGL(m_target), m_glBuffer);
GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");
if (!inputTypeIsFloatType(m_inputType))
{
// Input is not float type
if (outputTypeIsFloatType(m_outputType))
{
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x859736
cmpl $0x1, %eax
jne 0x8597f7
movq 0x10(%rbx), %rdi
movslq 0x34(%rbx), %rax
leaq 0x22c39c(%rip), %r14 # 0xa85a08
movl (%r14,%rax,4), %esi
movl 0x18(%rbx), %edx
movq (%rdi), %rax
callq *0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
deqp::gls::GLValue::getMaxValue(deqp::gls::Array::InputType) | GLValue GLValue::getMaxValue (Array::InputType type)
{
GLValue rangesHi[(int)Array::INPUTTYPE_LAST];
rangesHi[(int)Array::INPUTTYPE_FLOAT] = GLValue(Float::create(127.0f));
rangesHi[(int)Array::INPUTTYPE_DOUBLE] = GLValue(Double::create(127.0f));
rangesHi[(int)Array::INPUTTYPE_BYTE] = GLValue(Byte::create(12... | pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebx
xorl %eax, %eax
movl $0xc, 0x10(%rsp,%rax)
addq $0x10, %rax
cmpq $0xc0, %rax
jne 0x85bec2
movl $0x0, 0x10(%rsp)
movl $0x42fe0000, 0x18(%rsp) # imm = 0x42FE0000
movl $0x2, 0x30(%rsp)
movabsq $0x405fc00000000000, %rax # imm = 0x405FC00000000000
movq %rax, 0x38(%rsp)
movl $0x3, ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
deqp::gls::RandomArrayGenerator::generateQuads(int, int, int, int, int, deqp::gls::Array::Primitive, deqp::gls::Array::InputType, deqp::gls::GLValue, deqp::gls::GLValue, float) | char* RandomArrayGenerator::generateQuads (int seed, int count, int componentCount, int offset, int stride, Array::Primitive primitive, Array::InputType type, GLValue min, GLValue max, float gridSize)
{
char* data = DE_NULL;
switch (type)
{
case Array::INPUTTYPE_FLOAT:
data = createQuads<GLValue::Float>(seed, ... | pushq %rbx
movl 0x10(%rsp), %r11d
cmpq $0xb, %r11
ja 0x85c5d4
movaps %xmm0, %xmm2
leaq 0x28(%rsp), %rax
leaq 0x18(%rsp), %r10
leaq 0x2292f8(%rip), %rbx # 0xa857f0
movslq (%rbx,%r11,4), %r11
addq %rbx, %r11
jmpq *%r11
popq %rbx
jmp 0x85c5d8
movl 0x8(%r10), %r10d
movl 0x8(%rax), %eax
movaps %xmm2, %xmm0
pushq %rax
pus... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
deqp::gls::VertexArrayTest::VertexArrayTest(tcu::TestContext&, glu::RenderContext&, char const*, char const*) | VertexArrayTest::VertexArrayTest (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name ,const char* desc)
: TestCase (testCtx, name, desc)
, m_renderCtx (renderCtx)
, m_refBuffers (DE_NULL)
, m_refContext (DE_NULL)
, m_glesContext (DE_NULL)
, m_glArrayPack (DE_NULL)
, m_rrArrayPack ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, %rdx
movq %r8, %rcx
callq 0x9a9abc
leaq 0x3f965c(%rip), %rax # 0xc55f38
movq %rax, (%rbx)
movq %r14, 0x70(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x91(%rbx)
movq (%r14), %rax
movq %r14, %rdi
c... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
deqp::gls::MultiVertexArrayTest::Spec::ArraySpec::ArraySpec(deqp::gls::Array::InputType, deqp::gls::Array::OutputType, deqp::gls::Array::Storage, deqp::gls::Array::Usage, int, int, int, bool, deqp::gls::GLValue, deqp::gls::GLValue) | MultiVertexArrayTest::Spec::ArraySpec::ArraySpec(Array::InputType inputType_, Array::OutputType outputType_, Array::Storage storage_, Array::Usage usage_, int componentCount_, int offset_, int stride_, bool normalize_, GLValue min_, GLValue max_)
: inputType (inputType_)
, outputType (outputType_)
, storage (stora... | movb 0x18(%rsp), %al
movl 0x10(%rsp), %r10d
movl 0x8(%rsp), %r11d
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
movl %r9d, 0x10(%rdi)
movl %r11d, 0x14(%rdi)
movl %r10d, 0x18(%rdi)
movb %al, 0x1c(%rdi)
movups 0x20(%rsp), %xmm0
movups %xmm0, 0x20(%rdi)
movups 0x30(%rsp), %xmm0
movups %x... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
void deqp::gls::calcShaderColorCoord<unsigned int>(tcu::Vector<float, 2>&, tcu::Vector<float, 3>&, tcu::Vector<unsigned int, 4> const&, bool, int) | void calcShaderColorCoord (tcu::Vec2& coord, tcu::Vec3& color, const tcu::Vector<T, 4>& attribValue, bool isCoordinate, int numComponents)
{
if (isCoordinate)
switch (numComponents)
{
case 1: coord = tcu::Vec2((float)attribValue.x(), (float)attribValue.x()); break;
case 2: coord = tcu::Vec2((floa... | decl %r8d
testl %ecx, %ecx
je 0x85f85d
cmpl $0x3, %r8d
ja 0x85f992
leaq 0x225f0d(%rip), %rax # 0xa85750
movslq (%rax,%r8,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl (%rdx), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, (%rdi)
movss %xmm0, 0x4(%rdi)
retq
cmpl $0x3, %r8d
ja 0x85f992
leaq 0x225ed2(%rip), %rax # 0xa85740
movsl... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
char* deqp::gls::RandomArrayGenerator::createQuads<deqp::gls::GLValue::WrappedFloatType<double>>(int, int, int, int, int, deqp::gls::Array::Primitive, deqp::gls::GLValue::WrappedFloatType<double>, deqp::gls::GLValue::WrappedFloatType<double>, float) | char* RandomArrayGenerator::createQuads (int seed, int count, int componentCount, int offset, int stride, Array::Primitive primitive, T min, T max, float gridSize)
{
int componentStride = sizeof(T);
int quadStride = 0;
if (stride == 0)
stride = componentCount * componentStride;
DE_ASSERT(stride >= componentCoun... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movss %xmm2, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %r9d, %r12d
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r15d
leal (,%rbx,8), %r14d
testl %r8d, %r8d
cmovnel %r8d, %r14d
leal (%r14,%r14), %edx
xorl %eax, %eax
cm... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
char* deqp::gls::RandomArrayGenerator::createQuads<deqp::gls::GLValue::WrappedType<int>>(int, int, int, int, int, deqp::gls::Array::Primitive, deqp::gls::GLValue::WrappedType<int>, deqp::gls::GLValue::WrappedType<int>, float) | char* RandomArrayGenerator::createQuads (int seed, int count, int componentCount, int offset, int stride, Array::Primitive primitive, T min, T max, float gridSize)
{
int componentStride = sizeof(T);
int quadStride = 0;
if (stride == 0)
stride = componentCount * componentStride;
DE_ASSERT(stride >= componentCoun... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movss %xmm0, 0x8(%rsp)
movl %r9d, %r14d
movl %ecx, %ebp
movl %esi, %r12d
movl %edi, %r15d
movq %rdx, 0x10(%rsp)
leal (,%rdx,4), %eax
testl %r8d, %r8d
cmovnel %r8d, %eax
movq %rax, 0x50(%rsp)
leal (%rax,%rax), %ecx
xorl %eax, %eax
cmpl $0... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
char* deqp::gls::RandomArrayGenerator::createPerQuads<deqp::gls::GLValue::WrappedFloatType<float>>(int, int, int, int, deqp::gls::Array::Primitive, deqp::gls::GLValue::WrappedFloatType<float>, deqp::gls::GLValue::WrappedFloatType<float>) | char* RandomArrayGenerator::createPerQuads (int seed, int count, int componentCount, int stride, Array::Primitive primitive, T min, T max)
{
deRandom rnd;
deRandom_init(&rnd, seed);
int componentStride = sizeof(T);
if (stride == 0)
stride = componentStride * componentCount;
int quadStride = 0;
switch (primi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movss %xmm1, 0x4(%rsp)
movss %xmm0, (%rsp)
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %esi
leaq 0x68(%rsp), %rdi
callq 0x9fa2bc
movq %rbx, 0x20(%rsp)
leal (,%rbx,4), %ebx
testl %r15d, %r15d
cmovnel %r15d... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
char* deqp::gls::RandomArrayGenerator::createPerQuads<deqp::gls::GLValue::WrappedType<unsigned char>>(int, int, int, int, deqp::gls::Array::Primitive, deqp::gls::GLValue::WrappedType<unsigned char>, deqp::gls::GLValue::WrappedType<unsigned char>) | char* RandomArrayGenerator::createPerQuads (int seed, int count, int componentCount, int stride, Array::Primitive primitive, T min, T max)
{
deRandom rnd;
deRandom_init(&rnd, seed);
int componentStride = sizeof(T);
if (stride == 0)
stride = componentStride * componentCount;
int quadStride = 0;
switch (primi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebx
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r13d
movl %edi, %esi
leaq 0x78(%rsp), %rdi
callq 0x9fa2bc
testl %r15d, %r15d
movl %ebp, 0x4(%rsp)
cmovel %ebp, %r15d
leal (%r15,%r15), %r12d
xorl %ecx, %ecx
cm... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
char* deqp::gls::RandomArrayGenerator::createPerQuads<deqp::gls::GLValue::WrappedType<unsigned int>>(int, int, int, int, deqp::gls::Array::Primitive, deqp::gls::GLValue::WrappedType<unsigned int>, deqp::gls::GLValue::WrappedType<unsigned int>) | char* RandomArrayGenerator::createPerQuads (int seed, int count, int componentCount, int stride, Array::Primitive primitive, T min, T max)
{
deRandom rnd;
deRandom_init(&rnd, seed);
int componentStride = sizeof(T);
if (stride == 0)
stride = componentStride * componentCount;
int quadStride = 0;
switch (primi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebx
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r14d
movl %esi, %ebp
movl %edi, %esi
leaq 0x78(%rsp), %rdi
callq 0x9fa2bc
movq %r14, 0x28(%rsp)
leal (,%r14,4), %r14d
testl %r12d, %r12d
cmovnel %r12d, %r14d
leal (%r14,%r14),... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
char* deqp::gls::RandomArrayGenerator::createPerQuads<deqp::gls::GLValue::Half>(int, int, int, int, deqp::gls::Array::Primitive, deqp::gls::GLValue::Half, deqp::gls::GLValue::Half) | char* RandomArrayGenerator::createPerQuads (int seed, int count, int componentCount, int stride, Array::Primitive primitive, T min, T max)
{
deRandom rnd;
deRandom_init(&rnd, seed);
int componentStride = sizeof(T);
if (stride == 0)
stride = componentStride * componentCount;
int quadStride = 0;
switch (primi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebx
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r14d
movl %esi, %r13d
movl %edi, %esi
leaq 0x78(%rsp), %rdi
callq 0x9fa2bc
movq %r14, 0x20(%rsp)
addl %r14d, %r14d
testl %r12d, %r12d
cmovnel %r12d, %r14d
leal (%r14,%r14), %r... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsVertexArrayTests.cpp |
deqp::gls::AttributePack::newArray(deqp::gls::DrawTestSpec::Storage) | void AttributePack::newArray (DrawTestSpec::Storage storage)
{
m_arrays.push_back(new AttributeArray(storage, m_ctx));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x58, %edi
callq 0x325210
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0x864772
movq 0x20(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x864682
movq %r14, (%rax)
addq $0x8, 0x20(%rbx... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsDrawTest.cpp |
deqp::gls::AttributePack::render(deqp::gls::DrawTestSpec::Primitive, deqp::gls::DrawTestSpec::DrawMethod, int, int, deqp::gls::DrawTestSpec::IndexType, void const*, int, int, int, int, int, float, float, deqp::gls::(anonymous namespace)::AttributeArray*) | void AttributePack::render (DrawTestSpec::Primitive primitive, DrawTestSpec::DrawMethod drawMethod, int firstVertex, int vertexCount, DrawTestSpec::IndexType indexType, const void* indexOffset, int rangeStart, int rangeEnd, int instanceCount, int indirectOffset, int baseVertex, float coordScale, float colorScale, Attri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movss %xmm1, 0x28(%rsp)
movss %xmm0, 0x30(%rsp)
movl %r9d, 0x24(%rsp)
movl %r8d, 0x1c(%rsp)
movl %ecx, %ebp
movl %edx, 0x5c(%rsp)
movl %esi, 0x20(%rsp)
movq %rdi, %rbx
movq 0x250(%rsp), %r15
movq 0x10(%rdi), %rd... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsDrawTest.cpp |
deqp::gls::DrawTest::compare(deqp::gls::DrawTestSpec::Primitive) | bool DrawTest::compare (gls::DrawTestSpec::Primitive primitiveType)
{
const tcu::Surface& ref = m_rrArrayPack->getSurface();
const tcu::Surface& screen = m_glArrayPack->getSurface();
if (m_renderCtx.getRenderTarget().getNumSamples() > 1)
{
// \todo [mika] Improve compare when using multisampling
m_testCtx.get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x588, %rsp # imm = 0x588
movl %esi, %ebp
movq %rdi, %rbx
movq 0x98(%rdi), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rdi), %rdi
movq 0x90(%rbx), %r12
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0x2, 0x20(%rax)
jl 0x86cb7d
movq 0x8(%rbx), %rax
... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsDrawTest.cpp |
deqp::gls::(anonymous namespace)::DrawTestShaderProgram::shadeVertices(rr::VertexAttrib const*, rr::VertexPacket* const*, int) const | void DrawTestShaderProgram::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
{
const float u_coordScale = getUniformByName("u_coordScale").value.f;
const float u_colorScale = getUniformByName("u_colorScale").value.f;
for (int packetNdx = 0; packetNdx < num... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movq %rdx, 0x68(%rsp)
movq %rsi, %r14
movq %rdi, %r15
leaq 0x216be9(%rip), %rsi # 0xa85ada
callq 0x8b1e68
movss 0x24(%rax), %xmm0
movss %xmm0, 0x4c(%rsp)
leaq 0x1aad96(%rip), %rsi # 0xa19c9e
movq %r15, %rdi
callq 0x... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsDrawTest.cpp |
deqp::gls::(anonymous namespace)::DrawTestShaderProgram::shadeFragments(rr::FragmentPacket*, int, rr::FragmentShadingContext const&) const | void DrawTestShaderProgram::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
{
const size_t varyingLocColor = 0;
for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
{
rr::FragmentPacket& packet = packets[packetNdx];
for (int fragNdx = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
testl %edx, %edx
jle 0x86f9d0
movq %rcx, %rbx
movl %edx, %eax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movq %rbp, %r12
shlq $0x6, %r12
addq 0x20(%rsp), %r12
xorl %r13d, %r13d
movq... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsDrawTest.cpp |
deqp::gls::(anonymous namespace)::GLValue::getMinValue(deqp::gls::DrawTestSpec::InputType) | GLValue GLValue::getMinValue (DrawTestSpec::InputType type)
{
GLValue rangesLo[(int)DrawTestSpec::INPUTTYPE_LAST];
rangesLo[(int)DrawTestSpec::INPUTTYPE_FLOAT] = GLValue(Float::create(-127.0f));
rangesLo[(int)DrawTestSpec::INPUTTYPE_DOUBLE] = GLValue(Double::create(-127.0f));
rangesLo[(int)DrawTestSpec::INPUTT... | pushq %rbx
subq $0xd0, %rsp
movl %edi, %ebx
xorl %eax, %eax
movl $0xc, 0x10(%rsp,%rax)
addq $0x10, %rax
cmpq $0xc0, %rax
jne 0x870412
xorl %eax, %eax
movl %eax, 0x10(%rsp)
movl $0xc2fe0000, 0x18(%rsp) # imm = 0xC2FE0000
movl $0x2, 0x30(%rsp)
movabsq $-0x3fa0400000000000, %rcx # imm = 0xC05FC00000000000
movq %rcx, 0x38(... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsDrawTest.cpp |
deqp::gls::ShaderExecUtil::generatePassthroughFragmentShader(deqp::gls::ShaderExecUtil::ShaderSpec const&, bool, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pa... | static std::string generatePassthroughFragmentShader (const ShaderSpec& shaderSpec, bool useIntOutputs, const std::map<std::string, int>& outLocationMap, const std::string& inputPrefix, const std::string& outputPrefix)
{
DE_ASSERT(glu::glslVersionUsesInOutQualifiers(shaderSpec.version));
std::ostringstream src;
sr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movq %r9, %r15
movq %r8, (%rsp)
movq %rcx, %r13
movl %edx, 0xc(%rsp)
movq %rsi, %r12
movq %rdi, %r14
leaq 0xa0(%rsp), %rdi
callq 0x325e00
movl (%r12), %edi
callq 0x8bb762
movq %rax, %rbx
testq %rax, %rax
je 0x87... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::TessEvaluationExecutor::~TessEvaluationExecutor() | BufferIoExecutor::~BufferIoExecutor (void)
{
} | pushq %rbx
movq %rdi, %rbx
leaq 0x3e0ea3(%rip), %rax # 0xc56400
movq %rax, (%rdi)
movq 0x158(%rdi), %rdi
testq %rdi, %rdi
je 0x87557b
movq 0x168(%rbx), %rsi
subq %rdi, %rsi
callq 0x3251a0
movq 0x140(%rbx), %rdi
testq %rdi, %rdi
je 0x875596
movq 0x150(%rbx), %rsi
subq %rdi, %rsi
callq 0x3251a0
leaq 0x128(%rbx), %rdi
... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::BufferIoExecutor::copyFromBuffer(glu::VarType const&, deqp::gls::ShaderExecUtil::BufferIoExecutor::VarLayout const&, int, void const*, void*) | void BufferIoExecutor::copyFromBuffer (const glu::VarType& varType, const VarLayout& layout, int numValues, const void* srcBasePtr, void* dstBasePtr)
{
if (varType.isBasicType())
{
const glu::DataType basicType = varType.getBasicType();
const bool isMatrix = glu::isDataTypeMatrix(basicType);
const int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, 0x18(%rsp)
cmpl $0x0, (%rdi)
jne 0x875a05
movq %rsi, %r15
movq %rcx, 0x20(%rsp)
movq %r8, 0x28(%rsp)
movl 0x8(%rdi), %ebp
leal -0x5(%rbp), %eax
cmpl $0x9, %eax
setb %al
leal -0x12(%rbp), %ecx
cmpl $0x9, %ecx
setb %bl
orb %al, ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::BufferIoExecutor::uploadInputBuffer(void const* const*, int) | void BufferIoExecutor::uploadInputBuffer (const void* const* inputPtrs, int numValues)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
const deUint32 buffer = *m_inputBuffer;
const deUint32 inputStride = getLayoutStride(m_inputLayout);
const int inputBufferSize = inputStride*numValues;
if (i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
movq 0x140(%r15), %rax
cmpq 0x148(%r15), %rax
je 0x875acc
movl 0x4(%rax), %ebx
jmp 0x875ace
xorl %ebx, %ebx
im... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::BufferIoExecutor::readOutputBuffer(void* const*, int) | void BufferIoExecutor::readOutputBuffer (void* const* outputPtrs, int numValues)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
const deUint32 buffer = *m_outputBuffer;
const deUint32 outputStride = getLayoutStride(m_outputLayout);
const int outputBufferSize = numValues*outputStride;
DE_A... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
movl 0x138(%r15), %esi
movq 0x158(%r15), %rax
cmpq 0x160(%r15), %rax
je 0x875ca5
movl 0x4(%rax), %ebx
jmp 0x87... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::BufferIoExecutor::declareBufferBlocks(std::ostream&, deqp::gls::ShaderExecUtil::ShaderSpec const&) | void BufferIoExecutor::declareBufferBlocks (std::ostream& src, const ShaderSpec& spec)
{
// Input struct
if (!spec.inputs.empty())
{
glu::StructType inputStruct("Inputs");
for (vector<Symbol>::const_iterator symIter = spec.inputs.begin(); symIter != spec.inputs.end(); ++symIter)
inputStruct.addMember(symIter-... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq 0x10(%rsi), %rax
je 0x875ed4
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2114b0(%rip), %rsi # 0xa872ff
leaq 0x2114af(%rip), %rdx # 0xa87305
leaq 0x8(%rsp), %r15
movq %r15, %rdi... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::BufferIoExecutor::generateExecBufferIo(std::ostream&, deqp::gls::ShaderExecUtil::ShaderSpec const&, char const*) | void BufferIoExecutor::generateExecBufferIo (std::ostream& src, const ShaderSpec& spec, const char* invocationNdxName)
{
for (vector<Symbol>::const_iterator symIter = spec.inputs.begin(); symIter != spec.inputs.end(); ++symIter)
src << "\t" << glu::declare(symIter->varType, symIter->name) << " = inputs[" << invocati... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r12
movq %rsi, (%rsp)
cmpq 0x10(%rsi), %r12
je 0x8761c7
leaq 0x28(%rsp), %rbp
movl $0x1, %edx
movq %r15, %rdi
leaq 0x1e96e9(%rip), %rsi # 0xa5f7d0
callq 0x325e... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::ComputeShaderExecutor::generateComputeShader[abi:cxx11](deqp::gls::ShaderExecUtil::ShaderSpec const&) | std::string ComputeShaderExecutor::generateComputeShader (const ShaderSpec& spec)
{
std::ostringstream src;
src << glu::getGLSLVersionDeclaration(spec.version) << "\n";
if (!spec.globalDeclarations.empty())
src << spec.globalDeclarations << "\n";
src << "layout(local_size_x = 1) in;\n"
<< "\n";
declareBuff... | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x325e00
movl (%r14), %edi
callq 0x8bb762
movq %rax, %r15
testq %rax, %rax
je 0x8764da
movq %r15, %rdi
callq 0x325680
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x325e70... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::ComputeShaderExecutor::ComputeShaderExecutor(glu::RenderContext const&, deqp::gls::ShaderExecUtil::ShaderSpec const&) | ComputeShaderExecutor::ComputeShaderExecutor (const glu::RenderContext& renderCtx, const ShaderSpec& shaderSpec)
: BufferIoExecutor (renderCtx, shaderSpec,
glu::ProgramSources() << glu::ComputeSource(generateComputeShader(shaderSpec)))
{
m_maxWorkSize = tcu::IVec3(128,128,64); // Minimum in 3plus
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdi
movups %xmm0, 0xb9(%rdi)
movups %xmm0, 0xb0(%rdi)
movl $0xac, %edx
xorl %esi, %esi
callq 0x325500
leaq 0x8(%rsp), %rdi
movq %r14, %rs... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::ComputeShaderExecutor::execute(int, void const* const*, void* const*) | void ComputeShaderExecutor::execute (int numValues, const void* const* inputs, void* const* outputs)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
const int maxValuesPerInvocation = m_maxWorkSize[0];
const deUint32 inputStride = getInputStride();
const deUint32 outputStride = getOutputSt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, %rbx
movl %esi, 0x4(%rsp)
movq %rdi, %rbp
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r15
movq 0x140(%rbp), %rax
movl $0x0, (%rsp)
movl $0x0, %r13d
cmpq 0x148(%rbp), %rax
je 0x876... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::checkTessSupport(glu::RenderContext const&, deqp::gls::ShaderExecUtil::ShaderSpec const&, glu::ShaderType) | void checkTessSupport (const glu::RenderContext& renderCtx, const ShaderSpec& shaderSpec, glu::ShaderType stage)
{
const int numBlockRequired = 2; // highest binding is always 1 (output) i.e. count == 2
if (glu::glslVersionIsES(shaderSpec.version) && shaderSpec.version <= glu::GLSL_VERSION_310_ES)
checkExtension(r... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %edi
callq 0x8bb789
testb %al, %al
je 0x8769db
cmpl $0x2, (%r14)
jg 0x8769db
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x20b248(%rip), %rsi # 0xa81bed
leaq 0x20b25b(%rip), %rdx # 0xa81... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::checkLimit(glu::RenderContext const&, unsigned int, int) | static void checkLimit (const glu::RenderContext& renderCtx, deUint32 pname, int required)
{
const glw::Functions& gl = renderCtx.getFunctions();
int implementationLimit = -1;
deUint32 error;
gl.getIntegerv(pname, &implementationLimit);
error = gl.getError();
if (error != GL_NO_ERROR)
throw tcu::T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movl %esi, %r14d
movl $0x2, 0xc(%rsp)
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movl $0xffffffff, (%rsi) # imm = 0xFFFFFFFF
movl %r14d, %edi
callq *0x868(%rax)
callq *0x800(%rbx)
testl %e... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::TessControlExecutor::generateTessControlShader[abi:cxx11](deqp::gls::ShaderExecUtil::ShaderSpec const&) | std::string TessControlExecutor::generateTessControlShader (const ShaderSpec& shaderSpec)
{
std::ostringstream src;
src << glu::getGLSLVersionDeclaration(shaderSpec.version) << "\n";
if (glu::glslVersionIsES(shaderSpec.version) && shaderSpec.version <= glu::GLSL_VERSION_310_ES)
src << "#extension GL_EXT_tessella... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x325e00
movl (%r14), %edi
callq 0x8bb762
movq %rax, %r15
testq %rax, %rax
je 0x876f9b
movq %r15, %rdi
callq 0x325680
movq %rsp, %rdi
movq %r15, %rsi
movq %r... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::generateVertexShaderForTess[abi:cxx11](glu::GLSLVersion) | static std::string generateVertexShaderForTess (glu::GLSLVersion version)
{
std::ostringstream src;
src << glu::getGLSLVersionDeclaration(version) << "\n";
src << "void main (void)\n{\n"
<< " gl_Position = vec4(gl_VertexID/2, gl_VertexID%2, 0.0, 1.0);\n"
<< "}\n";
return src.str();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x325e00
movl %ebp, %edi
callq 0x8bb762
movq %rax, %r14
testq %rax, %rax
je 0x877773
movq %r14, %rdi
callq 0x325680
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x325e70
j... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::generateEmptyFragmentSource[abi:cxx11](glu::GLSLVersion) | static std::string generateEmptyFragmentSource (glu::GLSLVersion version)
{
const bool customOut = glu::glslVersionUsesInOutQualifiers(version);
std::ostringstream src;
src << glu::getGLSLVersionDeclaration(version) << "\n";
// \todo [2013-08-05 pyry] Do we need one dummy output?
src << "void main (void)\n{\... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %edi
callq 0x8bb774
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x325e00
movl %r14d, %edi
callq 0x8bb762
movq %rax, %r14
testq %rax, %rax
je 0x877892
movq %r14, %rdi
callq 0x325680
leaq 0x8(%rsp), %rdi... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::TessControlExecutor::execute(int, void const* const*, void* const*) | void TessControlExecutor::execute (int numValues, const void* const* inputs, void* const* outputs)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
initBuffers(numValues);
// Setup input buffer & copy data
uploadInputBuffer(inputs, numValues);
if (!m_inputs.empty())
gl.bindBufferBase(GL_SHADER_STORAGE... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r13
movl %esi, %r14d
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r12
movq %r15, %rdi
movl %r14d, %esi
callq 0x87569e
movq %r15, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x875a92
movq 0x10(%r15)... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::TessEvaluationExecutor::generateTessEvalShader[abi:cxx11](deqp::gls::ShaderExecUtil::ShaderSpec const&) | std::string TessEvaluationExecutor::generateTessEvalShader (const ShaderSpec& shaderSpec)
{
std::ostringstream src;
src << glu::getGLSLVersionDeclaration(shaderSpec.version) << "\n";
if (glu::glslVersionIsES(shaderSpec.version) && shaderSpec.version <= glu::GLSL_VERSION_310_ES)
src << "#extension GL_EXT_tessella... | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x325e00
movl (%r14), %edi
callq 0x8bb762
movq %rax, %r15
testq %rax, %rax
je 0x877ac2
movq %r15, %rdi
callq 0x325680
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x325e70... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::TessEvaluationExecutor::TessEvaluationExecutor(glu::RenderContext const&, deqp::gls::ShaderExecUtil::ShaderSpec const&) | TessEvaluationExecutor::TessEvaluationExecutor (const glu::RenderContext& renderCtx, const ShaderSpec& shaderSpec)
: BufferIoExecutor (renderCtx, shaderSpec, glu::ProgramSources()
<< glu::VertexSource(generateVertexShaderForTess(shaderSpec.version))
<< glu::TessellationControlSource(generatePassthroughTe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x348, %rsp # imm = 0x348
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x278(%rsp), %rdi
movups %xmm0, 0xb9(%rdi)
movups %xmm0, 0xb0(%rdi)
movl $0xac, %edx
xorl %esi, %esi
callq 0x325500
movl (%r14), %esi
leaq ... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::TessEvaluationExecutor::execute(int, void const* const*, void* const*) | void TessEvaluationExecutor::execute (int numValues, const void* const* inputs, void* const* outputs)
{
const glw::Functions& gl = m_renderCtx.getFunctions();
const int alignedValues = deAlign32(numValues, 2);
// Initialize buffers with aligned value count to make room for padding
initBuffers(alignedValues);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r13
movl %esi, %r14d
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r12
leal 0x1(%r14), %ebp
andl $-0x2, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x87569e
movq %r15, %rdi
movq... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
deqp::gls::ShaderExecUtil::createExecutor(glu::RenderContext const&, glu::ShaderType, deqp::gls::ShaderExecUtil::ShaderSpec const&) | ShaderExecutor* createExecutor (const glu::RenderContext& renderCtx, glu::ShaderType shaderType, const ShaderSpec& shaderSpec)
{
switch (shaderType)
{
case glu::SHADERTYPE_VERTEX: return new VertexShaderExecutor (renderCtx, shaderSpec);
case glu::SHADERTYPE_TESSELLATION_CONTROL: return TessControlExecutor:... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x5, %esi
ja 0x87840e
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %eax
leaq 0x20ec59(%rip), %rcx # 0xa86fbc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x158, %edi # imm = 0x158
callq 0x325210
movq %rax, %rbx
movq %rax, %rdi... | /kaydenl[P]VK-GL-CTS/modules/glshared/glsShaderExecUtil.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.