name string | code string | asm string | file string |
|---|---|---|---|
deqp::gles31::Functional::(anonymous namespace)::SRGBTestTexture::setDecode(deqp::gles31::Functional::(anonymous namespace)::SRGBDecode) | void SRGBTestTexture::setDecode (const SRGBDecode decoding)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindTexture(this->getGLTargetType(), this->getHandle());
switch (decoding)
{
case SRGBDECODE_SKIP_DECODE:
{
gl.texParameteri(this->getGLTargetType(), GL_TEXTURE_SRGB_DECO... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rdi
callq 0x4d7860
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0xb8(%rax), ... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::FragmentShaderParameters::FragmentShaderParameters(deqp::gles31::Functional::(anonymous namespace)::ShaderOutputs, deqp::gles31::Functional::(anonymous namespace)::ShaderUniforms, deqp::gles31::Functional::(anonymous namespace)::ComparisonFunction*, deqp::gles31::Functio... | FragmentShaderParameters::FragmentShaderParameters (const ShaderOutputs paramsOutputTotal,
const ShaderUniforms paramsUniformTotal,
ComparisonFunction* paramsComparisonFunction,
Blending paramsBlendRequired,
Toggling paramsToggleRequired)
: outputTotal ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x4(%rdi)
addq $0x10,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::SRGBTestTexture::setColor() | void SRGBTestTexture::setColor (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindTexture(this->getGLTargetType(), this->getHandle());
m_source.getRefTexture().allocLevel(0);
for (int py = 0; py < m_height; py++)
{
for (int px = 0; px < m_width; px++)
{
m_source.getRe... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rdi
callq 0x4d7860
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x65... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::SRGBTestCase::logColor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, tcu::Vector<float, 4>) const | void SRGBTestCase::logColor (const std::string& colorLogMessage, int colorIdx, tcu::Vec4 color) const
{
tcu::TestLog& log = m_context.getTestContext().getLog();
std::ostringstream message;
message << colorLogMessage << colorIdx << " = (" << color.x() << ", " << color.y() << ", " << color.z() << ", " << color.w(... | pushq %rbp
movq %rsp, %rbp
subq $0x3d0, %rsp # imm = 0x3D0
movq %rcx, -0x368(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x4d78a0
movq %rax, %rdi
callq 0x4d7990
movq %rax, -0x28(%rbp)
leaq -0x1a0(%rbp), %rd... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::TextureDecodeEnabledCase::verifyResult() | bool TextureDecodeEnabledCase::verifyResult (void)
{
tcu::TestLog& log = m_context.getTestContext().getLog();
const int resultColorIdx = 0;
std::vector<tcu::Vec4> pixelResultList;
tcu::Vec4 pixelConverted;
tcu::Vec4 pixelReference;
tcu::Vec4 pixelExpected;
this->readResultTextures();
this->sto... | pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp # imm = 0x4C0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x488(%rbp)
movq 0x70(%rax), %rdi
callq 0x4d78a0
movq %rax, %rdi
callq 0x4d7990
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x53bc90
leaq -0x50(%rbp), %rdi
callq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::TexelFetchDecodeSkippedcase::setupTest() | void TexelFetchDecodeSkippedcase::setupTest (void)
{
// TEST STEPS:
// - create and set texture to DECODE_SKIP_EXT
// - store texture on GPU
// - in fragment shader, sample the texture using texelFetch*() and render texel values to a color attachment in the FBO
// - on the host, read back the pixel values into a t... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
xorl %eax, %eax
movl %eax, %ecx
leaq -0x88(%rbp), %rdi
movl $0x1, %r9d
movl %r9d, %esi
movl %r9d, %edx
movl %r9d, %r8d
callq 0x653ae0
leaq -0x98(%rbp), %rdi
callq 0x653d20
jmp 0x656037
movq -0xb0(%rbp), %rdi
m... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::GPUConversionDecodeEnabledCase::setupTest() | void GPUConversionDecodeEnabledCase::setupTest (void)
{
// TEST STEPS:
// - create and set texture_a to DECODE_SKIP_EXT and texture_b to default
// - store textures on GPU
// - in fragment shader, sample both textures using texture*() and manually perform sRGB to lRGB conversion on texture_b
// - in fragment shade... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x160(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x4cc080
movq -0x158(%rbp), %rdx
leaq 0x7d954b(%rip), %rsi # 0xe2faf3
leaq -0x70(%rbp), %rdi
callq 0x4d20b0
jmp 0x6565b3
callq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::getFunctionDefinitionSRGBToLinearCheck() | const char* getFunctionDefinitionSRGBToLinearCheck (void)
{
static const char* functionDefinition =
"mediump vec4 srgbToLinearCheck(in mediump vec4 texelSRGBA, in mediump vec4 texelLinear) \n"
"{ \n"
" const int NUM_CHANNELS = 4;"
" mediump vec4 texelSRGBAConverted; \n"
" mediump vec4 epsilonErr = vec4(... | pushq %rbp
movq %rsp, %rbp
movq 0xa9424d(%rip), %rax # 0x10eadb8
popq %rbp
retq
nopl (%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::DecodeToggledCase::render() | void DecodeToggledCase::render (void)
{
// override the base SRGBTestCase render function with the purpose of switching between shader programs,
// toggling texture sRGB decode state between draw calls
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindFramebuffer(GL_FRAMEBUFFER, **m_fr... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x70(%rax), %rdi
callq 0x4d7860
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x40(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
addq $... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::DecodeMultipleTexturesCase::verifyResult() | bool DecodeMultipleTexturesCase::verifyResult (void)
{
tcu::TestLog& log = m_context.getTestContext().getLog();
const int resultColorIdx = 0;
std::vector<tcu::Vec4> pixelResultList;
tcu::Vec4 pixelExpected0;
tcu::Vec4 pixelExpected1;
this->readResultTextures();
this->storeResultPixels(pixelResultL... | pushq %rbp
movq %rsp, %rbp
subq $0x4c0, %rsp # imm = 0x4C0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x478(%rbp)
movq 0x70(%rax), %rdi
callq 0x4d78a0
movq %rax, %rdi
callq 0x4d7990
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x53bc90
leaq -0x50(%rbp), %rdi
callq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSRGBDecodeTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::BlockSingleNestedStructCase::init() | void init (void)
{
StructType& typeS = m_interface.allocStruct("S");
typeS.addMember("a", VarType(glu::TYPE_INT_VEC3, glu::PRECISION_HIGHP));
typeS.addMember("b", VarType(VarType(glu::TYPE_FLOAT_MAT3, glu::PRECISION_MEDIUMP), 4));
typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)); // \t... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x238(%rbp)
subq $-0x80, %rdi
leaq 0x83cc77(%rip), %rsi # 0xe9df9c
callq 0x9417b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x22... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::BlockSingleNestedStructArrayCase::init() | void init (void)
{
StructType& typeS = m_interface.allocStruct("S");
typeS.addMember("a", VarType(glu::TYPE_INT_VEC3, glu::PRECISION_HIGHP));
typeS.addMember("b", VarType(VarType(glu::TYPE_INT_VEC2, glu::PRECISION_MEDIUMP), 4));
typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP)); // \tod... | pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x268(%rbp)
subq $-0x80, %rdi
leaq 0x83c657(%rip), %rsi # 0xe9df9c
callq 0x9417b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x260(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x25... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::BlockUnsizedStructArrayCase::init() | void init (void)
{
StructType& typeS = m_interface.allocStruct("S");
typeS.addMember("a", VarType(glu::TYPE_UINT_VEC2, glu::PRECISION_HIGHP)); // \todo [pyry] UNUSED
typeS.addMember("b", VarType(VarType(glu::TYPE_FLOAT_MAT2X4, glu::PRECISION_MEDIUMP), 4));
typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC3, glu... | pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
subq $-0x80, %rdi
leaq 0x83bfb7(%rip), %rsi # 0xe9df9c
callq 0x9417b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x1c... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::Block2LevelUnsizedStructArrayCase::init() | void init (void)
{
StructType& typeS = m_interface.allocStruct("S");
typeS.addMember("a", VarType(glu::TYPE_INT_VEC3, glu::PRECISION_HIGHP));
typeS.addMember("c", VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP));
BufferBlock& block = m_interface.allocBlock("Block");
block.addMember(BufferVar("u", VarTyp... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
subq $-0x80, %rdi
leaq 0x83ba17(%rip), %rsi # 0xe9df9c
callq 0x9417b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x1b... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::BlockMultiBasicTypesCase::init() | void init (void)
{
BufferBlock& blockA = m_interface.allocBlock("BlockA");
blockA.addMember(BufferVar("a", VarType(glu::TYPE_FLOAT, glu::PRECISION_HIGHP), ACCESS_READ|ACCESS_WRITE));
blockA.addMember(BufferVar("b", VarType(glu::TYPE_UINT_VEC3, glu::PRECISION_LOWP), 0 /* no access */));
blockA.addMember(BufferV... | pushq %rbp
movq %rsp, %rbp
subq $0x310, %rsp # imm = 0x310
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2a8(%rbp)
subq $-0x80, %rdi
leaq 0x7cd3fb(%rip), %rsi # 0xe306b0
callq 0x9419b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2a0(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x29... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::RandomSSBOLayoutCase::RandomSSBOLayoutCase(deqp::gles31::Context&, char const*, char const*, deqp::gles31::SSBOLayoutCase::BufferMode, unsigned int, unsigned int) | RandomSSBOLayoutCase::RandomSSBOLayoutCase (Context& context, const char* name, const char* description, BufferMode bufferMode, deUint32 features, deUint32 seed)
: SSBOLayoutCase (context.getTestContext(), context.getRenderContext(), name, description, glu::GLSL_VERSION_310_ES, bufferMode)
, m_features (features)
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4d78a0
movq %rax, -0x38(%rbp)
movq -0x10(... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::RandomSSBOLayoutCase::init() | void RandomSSBOLayoutCase::init (void)
{
de::Random rnd(m_seed);
const int numBlocks = rnd.getInt(1, m_maxBlocks);
for (int ndx = 0; ndx < numBlocks; ndx++)
generateBlock(rnd, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0xcc(%rax), %esi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x523df0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movl 0xb4(%rax), %edx
movl $0x1, %esi
callq 0x524e80
movl %eax, -0x34(%rbp)
jmp ... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::RandomSSBOLayoutCase::generateBlock(de::Random&, unsigned int) | void RandomSSBOLayoutCase::generateBlock (de::Random& rnd, deUint32 layoutFlags)
{
DE_ASSERT(m_blockNdx <= 'z' - 'a');
const float instanceArrayWeight = 0.3f;
BufferBlock& block = m_interface.allocBlock((string("Block") + (char)('A' + m_blockNdx)).c_str());
int numInstances = (m_maxInstances > 0 && rnd.get... | pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movl $0x3e99999a, -0x18(%rbp) # imm = 0x3E99999A
subq $-0x80, %rax
movq %rax, -0x148(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x140(%rbp... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::RandomSSBOLayoutCase::generateBufferVar(de::Random&, deqp::gles31::bb::BufferBlock&, bool) | void RandomSSBOLayoutCase::generateBufferVar (de::Random& rnd, BufferBlock& block, bool isLastMember)
{
const float readWeight = 0.7f;
const float writeWeight = 0.7f;
const float accessWeight = 0.85f;
const bool unusedOk = (m_features & FEATURE_UNUSED_VARS) != 0;
const std::string name = genName(... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movss 0x7a982b(%rip), %xmm0 # 0xe0e20c
movss %xmm0, -0x20(%rbp)
movss 0x7a981e(%rip)... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::genName[abi:cxx11](char, char, int) | static std::string genName (char first, char last, int ndx)
{
std::string str = "";
int alphabetLen = last - first + 1;
while (ndx > alphabetLen)
{
str.insert(str.begin(), (char)(first + ((ndx-1)%alphabetLen)));
ndx = ((ndx-1) / alphabetLen);
}
str.insert(str.begin(), (char)(first + (ndx%(alphabetLen+1)... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movb %dl, %al
movb %sil, %dl
movq %rdi, %rsi
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movl %ecx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4cc080
movq -0x68(%rb... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOLayoutTests.cpp |
void de::Random::choose<glu::Precision const*, glu::Precision*>(glu::Precision const*, glu::Precision const*, glu::Precision*, int) | void Random::choose (InputIter first, InputIter last, OutputIter result, int numItems)
{
// Algorithm: Reservoir sampling
// http://en.wikipedia.org/wiki/Reservoir_sampling
// \note Will not work for suffling an array. Use suffle() instead.
int ndx;
for (ndx = 0; first != last; ++first, ++ndx)
{
if (ndx < numI... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x668115
movl -0x28(%rbp), %eax
cmpl -0x24(%r... | /kaydenl[P]VK-GL-CTS/framework/delibs/decpp/deRandom.hpp |
deqp::gles31::Functional::SSBOArrayLengthTests::init() | void SSBOArrayLengthTests::init (void)
{
static const struct Qualifier
{
SSBOArrayLengthCase::ArrayAccess access;
const char* name;
const char* desc;
} qualifiers[] =
{
{ SSBOArrayLengthCase::ACCESS_DEFAULT, "", "" },
{ SSBOArrayLengthCase::ACCESS_WRITEONLY, "writeonly_", "writeonly" },... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x668671
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x668661
leaq -0x90(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x4cb6d0
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOArrayLengthTests.cpp |
deqp::gles31::Functional::(anonymous namespace)::SSBOArrayLengthCase::deinit() | void SSBOArrayLengthCase::deinit (void)
{
if (m_shader)
{
delete m_shader;
m_shader = DE_NULL;
}
if (m_targetBufferID)
{
m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_targetBufferID);
m_targetBufferID = 0;
}
if (m_outputBufferID)
{
m_context.getRenderContext().getFunctions().delete... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x80(%rax)
je 0x669319
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x66930a
movq -0x18(%rbp), %rdi
callq 0xc2dc40
movq -0x18(%rbp), %rdi
movl $0xd0, %esi
c... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fSSBOArrayLengthTests.cpp |
deqp::gles31::Functional::CommonFunctionCase::CommonFunctionCase(deqp::gles31::Context&, char const*, char const*, glu::ShaderType) | CommonFunctionCase::CommonFunctionCase (Context& context, const char* name, const char* description, glu::ShaderType shaderType)
: TestCase (context, name, description)
, m_shaderType (shaderType)
, m_numValues (100)
, m_executor (DE_NULL)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4d85a0
movq -0x48(%rbp), %rdi
leaq 0xa58... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::CommonFunctionCase::init() | void CommonFunctionCase::init (void)
{
DE_ASSERT(!m_executor);
m_spec.version = contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) ? glu::GLSL_VERSION_320_ES : glu::GLSL_VERSION_310_ES;
m_executor = createExecutor(m_context.getRenderContext(), m_shaderType, m_spec);
m_testCtx.getLog()... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x70(%rax), %rdi
callq 0x4d7860
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
movl $0x3, %edi
movl $0x2, %esi
callq 0x4d7e70
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::CommonFunctionCase::iterate() | CommonFunctionCase::IterateResult CommonFunctionCase::iterate (void)
{
const int numInputScalars = computeTotalScalarSize(m_spec.inputs);
const int numOutputScalars = computeTotalScalarSize(m_spec.outputs);
vector<deUint32> inputData (numInputScalars * m_numValues);
vector<deUint32> outputData (num... | pushq %rbp
movq %rsp, %rbp
subq $0xc40, %rsp # imm = 0xC40
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xaa8(%rbp)
addq $0x88, %rdi
callq 0x66b290
movq -0xaa8(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0xa0, %rdi
callq 0x66b290
movq -0xaa8(%rbp), %rcx
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
mov... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::getInputOutputPointers(std::vector<deqp::gls::ShaderExecUtil::Symbol, std::allocator<deqp::gls::ShaderExecUtil::Symbol>> const&, std::vector<unsigned int, std::allocator<unsigned int>>&, int) | static vector<void*> getInputOutputPointers (const vector<Symbol>& symbols, vector<deUint32>& data, const int numValues)
{
vector<void*> pointers (symbols.size());
int curScalarOffset = 0;
for (int varNdx = 0; varNdx < (int)symbols.size(); ++varNdx)
{
const Symbol& var = symbols[varNdx];
const int scal... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66ebe0
movq %rax, -0x58(%rbp)
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x50... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::getScalarSizes(std::vector<deqp::gls::ShaderExecUtil::Symbol, std::allocator<deqp::gls::ShaderExecUtil::Symbol>> const&) | static vector<int> getScalarSizes (const vector<Symbol>& symbols)
{
vector<int> sizes(symbols.size());
for (int ndx = 0; ndx < (int)symbols.size(); ++ndx)
sizes[ndx] = symbols[ndx].varType.getScalarSize();
return sizes;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66ebe0
movq %rax, -0x38(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x4d3080
movq -0x40(%rbp), %rdi
m... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::ShaderCommonFunctionTests::init() | void ShaderCommonFunctionTests::init (void)
{
enum
{
VS = (1<<glu::SHADERTYPE_VERTEX),
TC = (1<<glu::SHADERTYPE_TESSELLATION_CONTROL),
TE = (1<<glu::SHADERTYPE_TESSELLATION_EVALUATION),
GS = (1<<glu::SHADERTYPE_GEOMETRY),
FS = (1<<glu::SHADERTYPE_FRAGMENT),
CS = (1<<glu::SHADERTYPE_COMPUTE),
ALL_SHADER... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0x7c5bef(%rip), %rsi # 0xe3120d
movl $0x1, %ecx
movl %ecx, -0x5c(%rbp)
xorl %r8d, %r8d
movl %r8d, -0x58(%rbp)
movl $0x3c, %r9d
movl %r9d, -0x60(%rbp)
movl %ecx, %edx
callq 0x66ba50
movl -0x60(%rbp), %r... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::AbsCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
callq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::SignCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::FloorCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::TruncCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::RoundEvenCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::CeilCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::FractCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::ModfCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::IsnanCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
void deqp::gles31::Functional::addFunctionCases<deqp::gles31::Functional::LdexpCase>(deqp::gles31::TestCaseGroup*, char const*, bool, bool, bool, unsigned int) | static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool floatTypes, bool intTypes, bool uintTypes, deUint32 shaderBits)
{
tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName);
parent->addChild(group);
const glu::DataType scalarTypes[] =... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
andb $0x1, %cl
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movl %r9d, -0x18(%rbp)
movl $0x70, %edi
callq 0x4cb2c0
movq %rax, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::getPrecisionPostfix(glu::Precision) | static const char* getPrecisionPostfix (glu::Precision precision)
{
static const char* s_postfix[] =
{
"_lowp",
"_mediump",
"_highp"
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_postfix) == glu::PRECISION_LAST);
DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(s_postfix)));
return s_postfix[precisio... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xa7d24d(%rip), %rax # 0x10eadd0
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::getShaderTypePostfix(glu::ShaderType) | static const char* getShaderTypePostfix (glu::ShaderType shaderType)
{
static const char* s_postfix[] =
{
"_vertex",
"_fragment",
"_geometry",
"_tess_control",
"_tess_eval",
"_compute"
};
DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_postfix)));
return s_postfix[shaderType];
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xa7d24d(%rip), %rax # 0x10eadf0
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::getMinMantissaBits(glu::Precision) | static int getMinMantissaBits (glu::Precision precision)
{
const int bits[] =
{
7, // lowp
10, // mediump
23 // highp
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(bits) == glu::PRECISION_LAST);
DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(bits)));
return bits[precision];
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x7c3362(%rip), %rax # 0xe31000
movq %rax, -0x10(%rbp)
movl 0x7c3360(%rip), %eax # 0xe31008
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl -0x10(%rbp,%rax,4), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::roundEven(float) | static float roundEven (float v)
{
const float q = deFloatFrac(v);
const int truncated = int(v-q);
const int rounded = (q > 0.5f) ? (truncated + 1) : // Rounded up
(q == 0.5f && (truncated % 2 != 0)) ? (truncated + 1) : // Round to nearest even at 0.5
truncated; // Rounded do... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x66dce0
movss %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
subss -0x8(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss 0x7a048a(%rip), %xmm1 # 0xe0e204
ucomiss %xmm1, %xmm0
jbe 0x66dd8... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::makeFloatRepresentable(float, glu::Precision) | static float makeFloatRepresentable (float f, glu::Precision precision)
{
if (precision == glu::PRECISION_HIGHP)
{
// \note: assuming f is not extended-precision
return f;
}
else
{
const int numMantissaBits = getMinMantissaBits(precision);
const int maxNormalizedValueExponent = getMaxNormalizedValue... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movss %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x66de05
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x66df75
movl -0xc(%rbp), %edi
callq 0x66dc90
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
callq 0x66df80
movl %eax, -0x14(%rbp)
movl -0xc(%rbp... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::BitsToFloatCase::BitsToFloatCase(deqp::gles31::Context&, glu::DataType, glu::ShaderType) | BitsToFloatCase (Context& context, glu::DataType baseType, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, glu::PRECISION_HIGHP, shaderType).c_str(), glu::isDataTypeIntOrIVec(baseType) ? "intBitsToFloat" : "uintBitsToFloat", shaderType)
{
const bool inIsSigned = glu::isD... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x168(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %ecx
leaq -0x38(%rbp), %r... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::BitsToFloatCase::~BitsToFloatCase() | BitsToFloatCase (Context& context, glu::DataType baseType, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, glu::PRECISION_HIGHP, shaderType).c_str(), glu::isDataTypeIntOrIVec(baseType) ? "intBitsToFloat" : "uintBitsToFloat", shaderType)
{
const bool inIsSigned = glu::isD... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x66a000
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::BitsToFloatCase::~BitsToFloatCase() | BitsToFloatCase (Context& context, glu::DataType baseType, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, glu::PRECISION_HIGHP, shaderType).c_str(), glu::isDataTypeIntOrIVec(baseType) ? "intBitsToFloat" : "uintBitsToFloat", shaderType)
{
const bool inIsSigned = glu::isD... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x66ecc0
movq -0x10(%rbp), %rdi
movl $0x280, %esi # imm = 0x280
callq 0x4cb230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::BitsToFloatCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
de::Random rnd (deStringHash(getName()) ^ 0xbbb225u);
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const int scalarSize = glu::getDataTypeScalarSize(type);
const Vec2 range (-1e8f, +1e8f);
// \note Filled a... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x524760
movq %rax, %rdi
callq 0xe00dd0
movl %eax, %esi
xorl $0xbbb225, %esi # imm = 0xBBB225
leaq -0x28(%rbp), %rdi
callq 0x523df0
movq -0x50(%rbp), ... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::AbsCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const int scalarSize = glu::getDataTypeScalarSize(type);
if (glu::isDataTypeFloatOrVec(ty... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x68(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::SignCase::SignCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | SignCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "sign", shaderType)
{
m_spec.inputs.push_back(Symbol("in0", glu::VarType(baseType, precision)));
m_spec.outputs.p... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::SignCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 floatRanges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e4f, 1e4f), // mediump - note: may end up as inf
Vec2(-1e8f, 1e8f) // highp - note: may end up as inf
};
const IVec2 intRanges[] =
{
IVec2(-(1<<7), (1<<7)-1),
IVe... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x79db67(%rip), %xmm0 # 0xe0e214
movss 0x79a2df(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), %rdi
movss 0x7c0aba(%rip),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FloorCase::FloorCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | FloorCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "floor", shaderType)
{
m_spec.inputs.push_back(Symbol("in0", glu::VarType(baseType, precision)));
m_spec.outputs... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FloorCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e3f, 1e3f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0xac23fu);
const glu::DataType type = m_spec.inputs[0].varType.getBasic... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x79d13a(%rip), %xmm0 # 0xe0e214
movss 0x7998b2(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), %rdi
movss 0x7c007d(%rip),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
tcu::Float<unsigned int, 8, 23, 127, 3u> tcu::Float<unsigned int, 8, 23, 127, 3u>::convert<unsigned short, 5, 10, 15, 3u>(tcu::Float<unsigned short, 5, 10, 15, 3u> const&) | Float<StorageType, ExponentBits, MantissaBits, ExponentBias, Flags>
Float<StorageType, ExponentBits, MantissaBits, ExponentBias, Flags>::convert
(const Float<OtherStorageType, OtherExponentBits, OtherMantissaBits, OtherExponentBias, OtherFlags>& other)
{
if (!(Flags & FLOAT_HAS_SIGN) && other.sign() < 0)
{
// Nega... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64c290
testb $0x1, %al
jne 0x67161b
jmp 0x671633
movq -0x10(%rbp), %rdi
callq 0x671820
movl %eax, %edi
callq 0x6717e0
movl %eax, -0x4(%rbp)
jmp 0x6717ce
movq -0x10(%rbp), %rdi
callq 0x64c2e0
testb $0x1, %al
jne 0x671642
jm... | /kaydenl[P]VK-GL-CTS/framework/common/tcuFloat.hpp |
tcu::Float<unsigned int, 8, 23, 127, 3u>::construct(int, int, unsigned int) | Float<StorageType, ExponentBits, MantissaBits, ExponentBias, Flags>
Float<StorageType, ExponentBits, MantissaBits, ExponentBias, Flags>::construct
(int sign, int exponent, StorageType mantissa)
{
// Repurpose this otherwise invalid input as a shorthand notation for zero (no need for caller to care about internal repr... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x1d(%rbp)
jne 0x671ac6
cmpl $0x0, -0x10(%rbp)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
xorl %eax, %eax
cmpl $-... | /kaydenl[P]VK-GL-CTS/framework/common/tcuFloat.hpp |
deqp::gles31::Functional::TruncCase::TruncCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | TruncCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "trunc", shaderType)
{
m_spec.inputs.push_back(Symbol("in0", glu::VarType(baseType, precision)));
m_spec.outputs... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::TruncCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e3f, 1e3f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0xac23fu);
const glu::DataType type = m_spec.inputs[0].varType.getBas... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x79c2d7(%rip), %xmm0 # 0xe0e214
movss 0x798a4f(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), %rdi
movss 0x7bf21a(%rip),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::getUlpDiffIgnoreZeroSign(float, float) | inline deUint32 getUlpDiffIgnoreZeroSign (float a, float b)
{
if (tcu::Float32(a).isZero())
return getUlpDiff(tcu::Float32::construct(tcu::Float32(b).sign(), 0, 0).asFloat(), b);
else if (tcu::Float32(b).isZero())
return getUlpDiff(a, tcu::Float32::construct(tcu::Float32(a).sign(), 0, 0).asFloat());
else
retur... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
leaq -0x10(%rbp), %rdi
callq 0x64c970
leaq -0x10(%rbp), %rdi
callq 0x64c780
testb $0x1, %al
jne 0x6725af
jmp 0x6725ec
movss -0xc(%rbp), %xmm0
leaq -0x18(%rbp), %rdi
callq 0x64c970
leaq -0x18(%rbp), %rdi
c... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::RoundCase::RoundCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | RoundCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "round", shaderType)
{
m_spec.inputs.push_back(Symbol("in0", glu::VarType(baseType, precision)));
m_spec.outputs... | pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::RoundCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e3f, 1e3f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0xac23fu);
const glu::DataType type = m_spec.inputs[0].varType.getBas... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x79b7f7(%rip), %xmm0 # 0xe0e214
movss 0x797f6f(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), %rdi
movss 0x7be73a(%rip),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::RoundCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const bool hasZeroSign = supportsSignedZero(precision);
const int scalarSize = glu::ge... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::RoundEvenCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const bool hasSignedZero = supportsSignedZero(precision);
const int scalarSize = glu::g... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x90(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::CeilCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e3f, 1e3f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0xac23fu);
const glu::DataType type = m_spec.inputs[0].varType.getBasic... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x79a23a(%rip), %xmm0 # 0xe0e214
movss 0x7969b2(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), %rdi
movss 0x7bd17d(%rip),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FractCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e3f, 1e3f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0xac23fu);
const glu::DataType type = m_spec.inputs[0].varType.getBas... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x799927(%rip), %xmm0 # 0xe0e214
movss 0x79609f(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), %rdi
movss 0x7bc86a(%rip),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FractCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const bool hasZeroSign = supportsSignedZero(precision);
const int scalarSize = glu::ge... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x90(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::ModfCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const bool hasZeroSign = supportsSignedZero(precision);
const int scalarSize = glu::ge... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x80(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::IsnanCase::IsnanCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | IsnanCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "isnan", shaderType)
{
DE_ASSERT(glu::isDataTypeFloatOrVec(baseType));
const int vecSize = glu::getDataTypeS... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::IsnanCase::~IsnanCase() | IsnanCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "isnan", shaderType)
{
DE_ASSERT(glu::isDataTypeFloatOrVec(baseType));
const int vecSize = glu::getDataTypeS... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x66a000
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::IsnanCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const int scalarSize = glu::getDataTypeScalarSize(type);
if (precision == glu::PRECISION_... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x58(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::IsinfCase::IsinfCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | IsinfCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "isinf", shaderType)
{
DE_ASSERT(glu::isDataTypeFloatOrVec(baseType));
const int vecSize = glu::getDataTypeS... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::IsinfCase::~IsinfCase() | IsinfCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "isinf", shaderType)
{
DE_ASSERT(glu::isDataTypeFloatOrVec(baseType));
const int vecSize = glu::getDataTypeS... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x66a000
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::IsinfCase::~IsinfCase() | IsinfCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "isinf", shaderType)
{
DE_ASSERT(glu::isDataTypeFloatOrVec(baseType));
const int vecSize = glu::getDataTypeS... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x6764d0
movq -0x10(%rbp), %rdi
movl $0x280, %esi # imm = 0x280
callq 0x4cb230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::IsinfCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
de::Random rnd (deStringHash(getName()) ^ 0xc2a39fu);
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const int scalarSize = glu::getDataT... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x524760
movq %rax, %rdi
callq 0xe00dd0
movl %eax, %esi
xorl $0xc2a39f, %esi # imm = 0xC2A39F
leaq -0x28(%rbp), %rdi
callq 0x523df0
movq -0x80(%rbp), ... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::IsinfCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const int scalarSize = glu::getDataTypeScalarSize(type);
if (precision == glu::PRECISION_... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x58(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FloatBitsToUintIntCase::FloatBitsToUintIntCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType, bool) | FloatBitsToUintIntCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType, bool outIsSigned)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), outIsSigned ? "floatBitsToInt" : "floatBitsToUint", shaderType)
{
const int vecSi... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FloatBitsToUintIntCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e3f, 1e3f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0x2790au);
const glu::DataType type = m_spec.inputs[0].varType.getBasic... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x79736a(%rip), %xmm0 # 0xe0e214
movss 0x793ae2(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), %rdi
movss 0x7ba2ad(%rip),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FloatBitsToUintIntCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const int scalarSize = glu::getDataTypeScalarSize(type);
const int mantissaBits = getM... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x70(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FloatBitsToUintIntCase::~FloatBitsToUintIntCase() | FloatBitsToUintIntCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType, bool outIsSigned)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), outIsSigned ? "floatBitsToInt" : "floatBitsToUint", shaderType)
{
const int vecSi... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x66a000
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FrexpCase::FrexpCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | FrexpCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "frexp", shaderType)
{
const int vecSize = glu::getDataTypeScalarSize(baseType);
const glu::DataType intType ... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FrexpCase::~FrexpCase() | FrexpCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "frexp", shaderType)
{
const int vecSize = glu::getDataTypeScalarSize(baseType);
const glu::DataType intType ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x677760
movq -0x10(%rbp), %rdi
movl $0x280, %esi # imm = 0x280
callq 0x4cb230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FrexpCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e3f, 1e3f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0x2790au);
const glu::DataType type = m_spec.inputs[0].varType.getBasic... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x796a37(%rip), %xmm0 # 0xe0e214
movss 0x7931af(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), %rdi
movss 0x7b997a(%rip),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FrexpCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const int scalarSize = glu::getDataTypeScalarSize(type);
const bool signedZero... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x70(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
tcu::Float<unsigned int, 8, 23, 127, 3u>::constructBits(int, int, unsigned int) | Float<StorageType, ExponentBits, MantissaBits, ExponentBias, Flags>
Float<StorageType, ExponentBits, MantissaBits, ExponentBias, Flags>::constructBits
(int sign, int exponent, StorageType mantissaBits)
{
const StorageType signBit = sign < 0 ? 1 : 0;
const StorageType exponentBits = exponent + ExponentBias;
DE_ASS... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x7f, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %esi
shll $0x1f, %... | /kaydenl[P]VK-GL-CTS/framework/common/tcuFloat.hpp |
deqp::gles31::Functional::LdexpCase::LdexpCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | LdexpCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "ldexp", shaderType)
{
const int vecSize = glu::getDataTypeScalarSize(baseType);
const glu::DataType intType ... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::LdexpCase::~LdexpCase() | LdexpCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "ldexp", shaderType)
{
const int vecSize = glu::getDataTypeScalarSize(baseType);
const glu::DataType intType ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x66a000
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::LdexpCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-1e3f, 1e3f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0x2790au);
const glu::DataType type = m_spec.inputs[0].varType.getB... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x795fa7(%rip), %xmm0 # 0xe0e214
movss 0x79271f(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp), ... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::LdexpCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const int scalarSize = glu::getDataTypeScalarSize(type);
const int mantissaBits = getM... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x70(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FmaCase::FmaCase(deqp::gles31::Context&, glu::DataType, glu::Precision, glu::ShaderType) | FmaCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "fma", shaderType)
{
m_spec.inputs.push_back(Symbol("a", glu::VarType(baseType, precision)));
m_spec.inputs.push_b... | pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x240(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %e... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FmaCase::~FmaCase() | FmaCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType)
: CommonFunctionCase(context, getCommonFuncCaseName(baseType, precision, shaderType).c_str(), "fma", shaderType)
{
m_spec.inputs.push_back(Symbol("a", glu::VarType(baseType, precision)));
m_spec.inputs.push_b... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x66a000
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FmaCase::init() | void init (void)
{
if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))
&& !m_context.getContextInfo().isExtensionSupported("GL_EXT_gpu_shader5"))
throw tcu::NotSupportedError("GL_EXT_gpu_shader5 not supported");
CommonFunctionCase::init();
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x70(%rax), %rdi
callq 0x4d7860
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0xc(%rbp)
movl $0x3, %edi
movl $0x2, %esi
callq 0x4d7e70
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FmaCase::getInputValues(int, void* const*) const | void getInputValues (int numValues, void* const* values) const
{
const Vec2 ranges[] =
{
Vec2(-2.0f, 2.0f), // lowp
Vec2(-127.f, 127.f), // mediump
Vec2(-1e7f, 1e7f) // highp
};
de::Random rnd (deStringHash(getName()) ^ 0xac23fu);
const glu::DataType type = m_spec.inputs[0].varType... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x30(%rbp), %rdi
movss 0x795087(%rip), %xmm0 # 0xe0e214
movss 0x7917ff(%rip), %xmm1 # 0xe0a994
callq 0x570520
leaq -0x28(%rbp),... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FmaCase::compare(void const* const*, void const* const*) | bool compare (const void* const* inputs, const void* const* outputs)
{
const glu::DataType type = m_spec.inputs[0].varType.getBasicType();
const glu::Precision precision = m_spec.inputs[0].varType.getPrecision();
const int scalarSize = glu::getDataTypeScalarSize(type);
for (int compNdx = 0; compNdx < ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x80, %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x66e2f0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5d34e0
movq -0x78(%rbp), %rdi
movl %eax,... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::FmaCase::fma(glu::Precision, float, float, float) | static tcu::Interval fma (glu::Precision precision, float a, float b, float c)
{
const tcu::FloatFormat formats[] =
{
// minExp maxExp mantissa exact, subnormals infinities NaN
tcu::FloatFormat(0, 0, 7, false, tcu::YES, tcu::MAYBE, tcu::MAYBE),
tcu::FloatFormat(-13, 13, 9, false, tcu::... | pushq %rbp
movq %rsp, %rbp
subq $0x660, %rsp # imm = 0x660
movq %rdi, -0x578(%rbp)
movq %rdi, -0x570(%rbp)
movl %esi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movss %xmm2, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
xorl %r8d, %r8d
movl $0x7, %ecx
movl $0x2, %r9d
movl %r8d, %esi
movl %r8d, %edx
movl... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderCommonFunctionTests.cpp |
deqp::gles31::Functional::ShaderPackingFunctionCase::ShaderPackingFunctionCase(deqp::gles31::Context&, char const*, char const*, glu::ShaderType) | ShaderPackingFunctionCase::ShaderPackingFunctionCase (Context& context, const char* name, const char* description, glu::ShaderType shaderType)
: TestCase (context, name, description)
, m_shaderType (shaderType)
, m_executor (DE_NULL)
{
m_spec.version = glu::getContextTypeGLSLVersion(context.getRenderContext().getT... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4d85a0
movq -0x48(%rbp), %rdi
leaq 0xa48... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderPackingFunctionTests.cpp |
deqp::gles31::Functional::ShaderPackingFunctionCase::init() | void ShaderPackingFunctionCase::init (void)
{
DE_ASSERT(!m_executor);
m_executor = createExecutor(m_context.getRenderContext(), m_shaderType, m_spec);
m_testCtx.getLog() << m_executor;
if (!m_executor->isOk())
throw tcu::TestError("Compile failed");
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x70(%rax), %rdi
callq 0x4d7860
movq -0x48(%rbp), %rdx
movq %rax, %rdi
movl 0x78(%rdx), %esi
addq $0x80, %rdx
callq 0xbda530
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq 0x8(%rax), %r... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderPackingFunctionTests.cpp |
deqp::gles31::Functional::ShaderPackingFunctionTests::init() | void ShaderPackingFunctionTests::init (void)
{
// New built-in functions in GLES 3.1
{
const glu::ShaderType allShaderTypes[] =
{
glu::SHADERTYPE_VERTEX,
glu::SHADERTYPE_TESSELLATION_CONTROL,
glu::SHADERTYPE_TESSELLATION_EVALUATION,
glu::SHADERTYPE_GEOMETRY,
glu::SHADERTYPE_FRAGMENT,
glu::SHADER... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x7b7122(%rip), %rax # 0xe31bf0
movq %rax, -0x20(%rbp)
movq 0x7b711f(%rip), %rax # 0xe31bf8
movq %rax, -0x18(%rbp)
movq 0x7b711c(%rip), %rax # 0xe31c00
movq %rax, -0x10(%rbp)
movl $0x0, -0x24(%rb... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderPackingFunctionTests.cpp |
deqp::gles31::Functional::getPrecisionPostfix(glu::Precision) | static const char* getPrecisionPostfix (glu::Precision precision)
{
static const char* s_postfix[] =
{
"_lowp",
"_mediump",
"_highp"
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_postfix) == glu::PRECISION_LAST);
DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(s_postfix)));
return s_postfix[precisio... | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xa6fdcd(%rip), %rax # 0x10eae20
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderPackingFunctionTests.cpp |
deqp::gles31::Functional::getShaderTypePostfix(glu::ShaderType) | static const char* getShaderTypePostfix (glu::ShaderType shaderType)
{
static const char* s_postfix[] =
{
"_vertex",
"_fragment",
"_geometry",
"_tess_control",
"_tess_eval",
"_compute"
};
DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_postfix)));
return s_postfix[shaderType];
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xa6fdcd(%rip), %rax # 0x10eae40
movq (%rax,%rcx,8), %rax
popq %rbp
retq
nopl (%rax)
| /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderPackingFunctionTests.cpp |
deqp::gles31::Functional::PackSnorm4x8Case::PackSnorm4x8Case(deqp::gles31::Context&, glu::ShaderType, glu::Precision) | PackSnorm4x8Case (Context& context, glu::ShaderType shaderType, glu::Precision precision)
: ShaderPackingFunctionCase (context, (string("packsnorm4x8") + getPrecisionPostfix(precision) + getShaderTypePostfix(shaderType)).c_str(), "packSnorm4x8", shaderType)
, m_precision (precision)
{
m_spec.inputs.push_back(... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x190(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x4cc080
movq... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderPackingFunctionTests.cpp |
deqp::gles31::Functional::UnpackSnorm4x8Case::UnpackSnorm4x8Case(deqp::gles31::Context&, glu::ShaderType) | UnpackSnorm4x8Case (Context& context, glu::ShaderType shaderType)
: ShaderPackingFunctionCase(context, (string("unpacksnorm4x8") + getShaderTypePostfix(shaderType)).c_str(), "unpackSnorm4x8", shaderType)
{
m_spec.inputs.push_back(Symbol("in0", glu::VarType(glu::TYPE_UINT, glu::PRECISION_HIGHP)));
m_spec.outputs.... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x178(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x170(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x168(%rbp)
callq 0x4cc080
movq -0x168(%rbp), %rdx
lea... | /kaydenl[P]VK-GL-CTS/modules/gles31/functional/es31fShaderPackingFunctionTests.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.