/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Shader execution utilities.
 *//*--------------------------------------------------------------------*/

#include "glsShaderExecUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluDrawUtil.hpp"
#include "gluObjectWrapper.hpp"
#include "gluShaderProgram.hpp"
#include "gluTextureUtil.hpp"
#include "gluProgramInterfaceQuery.hpp"
#include "gluPixelTransfer.hpp"
#include "gluStrUtil.hpp"
#include "tcuTestLog.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "deSTLUtil.hpp"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include "deMemory.h"

#include <map>

namespace deqp
{
namespace gls
{

namespace ShaderExecUtil
{

using std::vector;

static bool isExtensionSupported(const glu::RenderContext &renderCtx, const std::string &extension)
{
    const glw::Functions &gl = renderCtx.getFunctions();
    int numExts              = 0;

    gl.getIntegerv(GL_NUM_EXTENSIONS, &numExts);

    for (int ndx = 0; ndx < numExts; ndx++)
    {
        const char *curExt = (const char *)gl.getStringi(GL_EXTENSIONS, ndx);

        if (extension == curExt)
            return true;
    }

    return false;
}

static void checkExtension(const glu::RenderContext &renderCtx, const std::string &extension)
{
    if (!isExtensionSupported(renderCtx, extension))
        throw tcu::NotSupportedError(extension + " is not supported");
}

static void checkLimit(const glu::RenderContext &renderCtx, uint32_t pname, int required)
{
    const glw::Functions &gl = renderCtx.getFunctions();
    int implementationLimit  = -1;
    uint32_t error;

    gl.getIntegerv(pname, &implementationLimit);
    error = gl.getError();

    if (error != GL_NO_ERROR)
        throw tcu::TestError("Failed to query " + de::toString(glu::getGettableStateStr(pname)) + " - got " +
                             de::toString(glu::getErrorStr(error)));
    if (implementationLimit < required)
        throw tcu::NotSupportedError("Test requires " + de::toString(glu::getGettableStateStr(pname)) +
                                     " >= " + de::toString(required) + ", got " + de::toString(implementationLimit));
}

// Shader utilities

static std::string generateVertexShader(const ShaderSpec &shaderSpec, const std::string &inputPrefix,
                                        const std::string &outputPrefix)
{
    const bool usesInout = glu::glslVersionUsesInOutQualifiers(shaderSpec.version);
    const char *in       = usesInout ? "in" : "attribute";
    const char *out      = usesInout ? "out" : "varying";
    std::ostringstream src;

    DE_ASSERT(!inputPrefix.empty() && !outputPrefix.empty());

    src << glu::getGLSLVersionDeclaration(shaderSpec.version) << "\n";

    if (!shaderSpec.globalDeclarations.empty())
        src << shaderSpec.globalDeclarations << "\n";

    src << in << " highp vec4 a_position;\n";

    for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input)
        src << in << " " << glu::declare(input->varType, inputPrefix + input->name) << ";\n";

    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
    {
        DE_ASSERT(output->varType.isBasicType());

        if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType()))
        {
            const int vecSize               = glu::getDataTypeScalarSize(output->varType.getBasicType());
            const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT;
            const glu::VarType intType(intBaseType, glu::PRECISION_HIGHP);

            src << "flat " << out << " " << glu::declare(intType, outputPrefix + output->name) << ";\n";
        }
        else
            src << "flat " << out << " " << glu::declare(output->varType, outputPrefix + output->name) << ";\n";
    }

    src << "\n"
        << "void main (void)\n"
        << "{\n"
        << "    gl_Position = a_position;\n"
        << "    gl_PointSize = 1.0;\n\n";

    // Declare & fetch local input variables
    for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input)
        src << "\t" << glu::declare(input->varType, input->name) << " = " << inputPrefix << input->name << ";\n";

    // Declare local output variables
    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
        src << "\t" << glu::declare(output->varType, output->name) << ";\n";

    // Operation - indented to correct level.
    {
        std::istringstream opSrc(shaderSpec.source);
        std::string line;

        while (std::getline(opSrc, line))
            src << "\t" << line << "\n";
    }

    // Assignments to outputs.
    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
    {
        if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType()))
        {
            const int vecSize               = glu::getDataTypeScalarSize(output->varType.getBasicType());
            const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT;

            src << "\t" << outputPrefix << output->name << " = " << glu::getDataTypeName(intBaseType) << "("
                << output->name << ");\n";
        }
        else
            src << "\t" << outputPrefix << output->name << " = " << output->name << ";\n";
    }

    src << "}\n";

    return src.str();
}

static std::string generateGeometryShader(const ShaderSpec &shaderSpec, const std::string &inputPrefix,
                                          const std::string &outputPrefix)
{
    DE_ASSERT(glu::glslVersionUsesInOutQualifiers(shaderSpec.version));
    DE_ASSERT(!inputPrefix.empty() && !outputPrefix.empty());

    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_geometry_shader : require\n";

    if (!shaderSpec.globalDeclarations.empty())
        src << shaderSpec.globalDeclarations << "\n";

    src << "layout(points) in;\n"
        << "layout(points, max_vertices = 1) out;\n";

    for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input)
        src << "flat in " << glu::declare(input->varType, inputPrefix + input->name) << "[];\n";

    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
    {
        DE_ASSERT(output->varType.isBasicType());

        if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType()))
        {
            const int vecSize               = glu::getDataTypeScalarSize(output->varType.getBasicType());
            const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT;
            const glu::VarType intType(intBaseType, glu::PRECISION_HIGHP);

            src << "flat out " << glu::declare(intType, outputPrefix + output->name) << ";\n";
        }
        else
            src << "flat out " << glu::declare(output->varType, outputPrefix + output->name) << ";\n";
    }

    src << "\n"
        << "void main (void)\n"
        << "{\n"
        << "    gl_Position = gl_in[0].gl_Position;\n\n";

    // Fetch input variables
    for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input)
        src << "\t" << glu::declare(input->varType, input->name) << " = " << inputPrefix << input->name << "[0];\n";

    // Declare local output variables.
    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
        src << "\t" << glu::declare(output->varType, output->name) << ";\n";

    src << "\n";

    // Operation - indented to correct level.
    {
        std::istringstream opSrc(shaderSpec.source);
        std::string line;

        while (std::getline(opSrc, line))
            src << "\t" << line << "\n";
    }

    // Assignments to outputs.
    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
    {
        if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType()))
        {
            const int vecSize               = glu::getDataTypeScalarSize(output->varType.getBasicType());
            const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT;

            src << "\t" << outputPrefix << output->name << " = " << glu::getDataTypeName(intBaseType) << "("
                << output->name << ");\n";
        }
        else
            src << "\t" << outputPrefix << output->name << " = " << output->name << ";\n";
    }

    src << "    EmitVertex();\n"
        << "    EndPrimitive();\n"
        << "}\n";

    return src.str();
}

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 unused output?

    src << "void main (void)\n{\n";
    if (!customOut)
        src << "    gl_FragColor = vec4(0.0);\n";
    src << "}\n";

    return src.str();
}

static std::string generatePassthroughVertexShader(const ShaderSpec &shaderSpec, const std::string &inputPrefix,
                                                   const std::string &outputPrefix)
{
    // flat qualifier is not present in earlier versions?
    DE_ASSERT(glu::glslVersionUsesInOutQualifiers(shaderSpec.version));

    std::ostringstream src;

    src << glu::getGLSLVersionDeclaration(shaderSpec.version) << "\n"
        << "in highp vec4 a_position;\n";

    for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input)
    {
        src << "in " << glu::declare(input->varType, inputPrefix + input->name) << ";\n"
            << "flat out " << glu::declare(input->varType, outputPrefix + input->name) << ";\n";
    }

    src << "\nvoid main (void)\n{\n"
        << "    gl_Position = a_position;\n"
        << "    gl_PointSize = 1.0;\n";

    for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input)
        src << "\t" << outputPrefix << input->name << " = " << inputPrefix << input->name << ";\n";

    src << "}\n";

    return src.str();
}

static void generateFragShaderOutputDecl(std::ostream &src, const ShaderSpec &shaderSpec, bool useIntOutputs,
                                         const std::map<std::string, int> &outLocationMap,
                                         const std::string &outputPrefix)
{
    DE_ASSERT(glu::glslVersionUsesInOutQualifiers(shaderSpec.version));

    for (int outNdx = 0; outNdx < (int)shaderSpec.outputs.size(); ++outNdx)
    {
        const Symbol &output         = shaderSpec.outputs[outNdx];
        const int location           = de::lookup(outLocationMap, output.name);
        const std::string outVarName = outputPrefix + output.name;
        glu::VariableDeclaration decl(output.varType, outVarName, glu::STORAGE_OUT, glu::INTERPOLATION_LAST,
                                      glu::Layout(location));

        TCU_CHECK_INTERNAL(output.varType.isBasicType());

        if (useIntOutputs && glu::isDataTypeFloatOrVec(output.varType.getBasicType()))
        {
            const int vecSize                 = glu::getDataTypeScalarSize(output.varType.getBasicType());
            const glu::DataType uintBasicType = vecSize > 1 ? glu::getDataTypeUintVec(vecSize) : glu::TYPE_UINT;
            const glu::VarType uintType(uintBasicType, glu::PRECISION_HIGHP);

            decl.varType = uintType;
            src << decl << ";\n";
        }
        else if (glu::isDataTypeBoolOrBVec(output.varType.getBasicType()))
        {
            const int vecSize                = glu::getDataTypeScalarSize(output.varType.getBasicType());
            const glu::DataType intBasicType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT;
            const glu::VarType intType(intBasicType, glu::PRECISION_HIGHP);

            decl.varType = intType;
            src << decl << ";\n";
        }
        else if (glu::isDataTypeMatrix(output.varType.getBasicType()))
        {
            const int vecSize                 = glu::getDataTypeMatrixNumRows(output.varType.getBasicType());
            const int numVecs                 = glu::getDataTypeMatrixNumColumns(output.varType.getBasicType());
            const glu::DataType uintBasicType = glu::getDataTypeUintVec(vecSize);
            const glu::VarType uintType(uintBasicType, glu::PRECISION_HIGHP);

            decl.varType = uintType;
            for (int vecNdx = 0; vecNdx < numVecs; ++vecNdx)
            {
                decl.name            = outVarName + "_" + de::toString(vecNdx);
                decl.layout.location = location + vecNdx;
                src << decl << ";\n";
            }
        }
        else
            src << decl << ";\n";
    }
}

static void generateFragShaderOutAssign(std::ostream &src, const ShaderSpec &shaderSpec, bool useIntOutputs,
                                        const std::string &valuePrefix, const std::string &outputPrefix)
{
    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
    {
        if (useIntOutputs && glu::isDataTypeFloatOrVec(output->varType.getBasicType()))
            src << "    o_" << output->name << " = floatBitsToUint(" << valuePrefix << output->name << ");\n";
        else if (glu::isDataTypeMatrix(output->varType.getBasicType()))
        {
            const int numVecs = glu::getDataTypeMatrixNumColumns(output->varType.getBasicType());

            for (int vecNdx = 0; vecNdx < numVecs; ++vecNdx)
                if (useIntOutputs)
                    src << "\t" << outputPrefix << output->name << "_" << vecNdx << " = floatBitsToUint(" << valuePrefix
                        << output->name << "[" << vecNdx << "]);\n";
                else
                    src << "\t" << outputPrefix << output->name << "_" << vecNdx << " = " << valuePrefix << output->name
                        << "[" << vecNdx << "];\n";
        }
        else if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType()))
        {
            const int vecSize               = glu::getDataTypeScalarSize(output->varType.getBasicType());
            const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT;

            src << "\t" << outputPrefix << output->name << " = " << glu::getDataTypeName(intBaseType) << "("
                << valuePrefix << output->name << ");\n";
        }
        else
            src << "\t" << outputPrefix << output->name << " = " << valuePrefix << output->name << ";\n";
    }
}

static std::string generateFragmentShader(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;

    src << glu::getGLSLVersionDeclaration(shaderSpec.version) << "\n";

    if (!shaderSpec.globalDeclarations.empty())
        src << shaderSpec.globalDeclarations << "\n";

    for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input)
        src << "flat in " << glu::declare(input->varType, inputPrefix + input->name) << ";\n";

    generateFragShaderOutputDecl(src, shaderSpec, useIntOutputs, outLocationMap, outputPrefix);

    src << "\nvoid main (void)\n{\n";

    // Declare & fetch local input variables
    for (vector<Symbol>::const_iterator input = shaderSpec.inputs.begin(); input != shaderSpec.inputs.end(); ++input)
        src << "\t" << glu::declare(input->varType, input->name) << " = " << inputPrefix << input->name << ";\n";

    // Declare output variables
    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
        src << "\t" << glu::declare(output->varType, output->name) << ";\n";

    // Operation - indented to correct level.
    {
        std::istringstream opSrc(shaderSpec.source);
        std::string line;

        while (std::getline(opSrc, line))
            src << "\t" << line << "\n";
    }

    generateFragShaderOutAssign(src, shaderSpec, useIntOutputs, "", outputPrefix);

    src << "}\n";

    return src.str();
}

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;

    src << glu::getGLSLVersionDeclaration(shaderSpec.version) << "\n";

    if (!shaderSpec.globalDeclarations.empty())
        src << shaderSpec.globalDeclarations << "\n";

    for (vector<Symbol>::const_iterator output = shaderSpec.outputs.begin(); output != shaderSpec.outputs.end();
         ++output)
    {
        if (glu::isDataTypeBoolOrBVec(output->varType.getBasicType()))
        {
            const int vecSize               = glu::getDataTypeScalarSize(output->varType.getBasicType());
            const glu::DataType intBaseType = vecSize > 1 ? glu::getDataTypeIntVec(vecSize) : glu::TYPE_INT;
            const glu::VarType intType(intBaseType, glu::PRECISION_HIGHP);

            src << "flat in " << glu::declare(intType, inputPrefix + output->name) << ";\n";
        }
        else
            src << "flat in " << glu::declare(output->varType, inputPrefix + output->name) << ";\n";
    }

    generateFragShaderOutputDecl(src, shaderSpec, useIntOutputs, outLocationMap, outputPrefix);

    src << "\nvoid main (void)\n{\n";

    generateFragShaderOutAssign(src, shaderSpec, useIntOutputs, inputPrefix, outputPrefix);

    src << "}\n";

    return src.str();
}

// ShaderExecutor

ShaderExecutor::ShaderExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec)
    : m_renderCtx(renderCtx)
    , m_inputs(shaderSpec.inputs)
    , m_outputs(shaderSpec.outputs)
{
}

ShaderExecutor::~ShaderExecutor(void)
{
}

void ShaderExecutor::useProgram(void)
{
    DE_ASSERT(isOk());
    m_renderCtx.getFunctions().useProgram(getProgram());
}

// FragmentOutExecutor

struct FragmentOutputLayout
{
    std::vector<const Symbol *> locationSymbols; //! Symbols by location
    std::map<std::string, int> locationMap;      //! Map from symbol name to start location
};

class FragmentOutExecutor : public ShaderExecutor
{
public:
    FragmentOutExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);
    ~FragmentOutExecutor(void);

    void execute(int numValues, const void *const *inputs, void *const *outputs);

protected:
    const FragmentOutputLayout m_outputLayout;
};

static FragmentOutputLayout computeFragmentOutputLayout(const std::vector<Symbol> &symbols)
{
    FragmentOutputLayout ret;
    int location = 0;

    for (std::vector<Symbol>::const_iterator it = symbols.begin(); it != symbols.end(); ++it)
    {
        const int numLocations = glu::getDataTypeNumLocations(it->varType.getBasicType());

        TCU_CHECK_INTERNAL(!de::contains(ret.locationMap, it->name));
        de::insert(ret.locationMap, it->name, location);
        location += numLocations;

        for (int ndx = 0; ndx < numLocations; ++ndx)
            ret.locationSymbols.push_back(&*it);
    }

    return ret;
}

inline bool hasFloatRenderTargets(const glu::RenderContext &renderCtx)
{
    glu::ContextType type = renderCtx.getType();
    return glu::isContextTypeGLCore(type);
}

FragmentOutExecutor::FragmentOutExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec)
    : ShaderExecutor(renderCtx, shaderSpec)
    , m_outputLayout(computeFragmentOutputLayout(m_outputs))
{
}

FragmentOutExecutor::~FragmentOutExecutor(void)
{
}

inline int queryInt(const glw::Functions &gl, uint32_t pname)
{
    int value = 0;
    gl.getIntegerv(pname, &value);
    return value;
}

static tcu::TextureFormat getRenderbufferFormatForOutput(const glu::VarType &outputType, bool useIntOutputs)
{
    const tcu::TextureFormat::ChannelOrder channelOrderMap[] = {tcu::TextureFormat::R, tcu::TextureFormat::RG,
                                                                tcu::TextureFormat::RGBA, // No RGB variants available.
                                                                tcu::TextureFormat::RGBA};

    const glu::DataType basicType = outputType.getBasicType();
    const int numComps            = glu::getDataTypeNumComponents(basicType);
    tcu::TextureFormat::ChannelType channelType;

    switch (glu::getDataTypeScalarType(basicType))
    {
    case glu::TYPE_UINT:
        channelType = tcu::TextureFormat::UNSIGNED_INT32;
        break;
    case glu::TYPE_INT:
        channelType = tcu::TextureFormat::SIGNED_INT32;
        break;
    case glu::TYPE_BOOL:
        channelType = tcu::TextureFormat::SIGNED_INT32;
        break;
    case glu::TYPE_FLOAT:
        channelType = useIntOutputs ? tcu::TextureFormat::UNSIGNED_INT32 : tcu::TextureFormat::FLOAT;
        break;
    default:
        throw tcu::InternalError("Invalid output type");
    }

    DE_ASSERT(de::inRange<int>(numComps, 1, DE_LENGTH_OF_ARRAY(channelOrderMap)));

    return tcu::TextureFormat(channelOrderMap[numComps - 1], channelType);
}

void FragmentOutExecutor::execute(int numValues, const void *const *inputs, void *const *outputs)
{
    const glw::Functions &gl      = m_renderCtx.getFunctions();
    const bool useIntOutputs      = !hasFloatRenderTargets(m_renderCtx);
    const int maxRenderbufferSize = queryInt(gl, GL_MAX_RENDERBUFFER_SIZE);
    const int framebufferW        = de::min(maxRenderbufferSize, numValues);
    const int framebufferH        = (numValues / framebufferW) + ((numValues % framebufferW != 0) ? 1 : 0);

    glu::Framebuffer framebuffer(m_renderCtx);
    glu::RenderbufferVector renderbuffers(m_renderCtx, m_outputLayout.locationSymbols.size());

    vector<glu::VertexArrayBinding> vertexArrays;
    vector<tcu::Vec2> positions(numValues);

    if (framebufferH > maxRenderbufferSize)
        throw tcu::NotSupportedError("Value count is too high for maximum supported renderbuffer size");

    // Compute positions - 1px points are used to drive fragment shading.
    for (int valNdx = 0; valNdx < numValues; valNdx++)
    {
        const int ix   = valNdx % framebufferW;
        const int iy   = valNdx / framebufferW;
        const float fx = -1.0f + 2.0f * ((float(ix) + 0.5f) / float(framebufferW));
        const float fy = -1.0f + 2.0f * ((float(iy) + 0.5f) / float(framebufferH));

        positions[valNdx] = tcu::Vec2(fx, fy);
    }

    // Vertex inputs.
    vertexArrays.push_back(glu::va::Float("a_position", 2, numValues, 0, (const float *)&positions[0]));

    for (int inputNdx = 0; inputNdx < (int)m_inputs.size(); inputNdx++)
    {
        const Symbol &symbol          = m_inputs[inputNdx];
        const std::string attribName  = "a_" + symbol.name;
        const void *ptr               = inputs[inputNdx];
        const glu::DataType basicType = symbol.varType.getBasicType();
        const int vecSize             = glu::getDataTypeScalarSize(basicType);

        if (glu::isDataTypeFloatOrVec(basicType))
            vertexArrays.push_back(glu::va::Float(attribName, vecSize, numValues, 0, (const float *)ptr));
        else if (glu::isDataTypeIntOrIVec(basicType))
            vertexArrays.push_back(glu::va::Int32(attribName, vecSize, numValues, 0, (const int32_t *)ptr));
        else if (glu::isDataTypeUintOrUVec(basicType))
            vertexArrays.push_back(glu::va::Uint32(attribName, vecSize, numValues, 0, (const uint32_t *)ptr));
        else if (glu::isDataTypeMatrix(basicType))
        {
            int numRows = glu::getDataTypeMatrixNumRows(basicType);
            int numCols = glu::getDataTypeMatrixNumColumns(basicType);
            int stride  = numRows * numCols * (int)sizeof(float);

            for (int colNdx = 0; colNdx < numCols; ++colNdx)
                vertexArrays.push_back(glu::va::Float(attribName, colNdx, numRows, numValues, stride,
                                                      ((const float *)ptr) + colNdx * numRows));
        }
        else
            DE_ASSERT(false);
    }

    // Construct framebuffer.
    gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer);

    for (int outNdx = 0; outNdx < (int)m_outputLayout.locationSymbols.size(); ++outNdx)
    {
        const Symbol &output        = *m_outputLayout.locationSymbols[outNdx];
        const uint32_t renderbuffer = renderbuffers[outNdx];
        const uint32_t format = glu::getInternalFormat(getRenderbufferFormatForOutput(output.varType, useIntOutputs));

        gl.bindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
        gl.renderbufferStorage(GL_RENDERBUFFER, format, framebufferW, framebufferH);
        gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + outNdx, GL_RENDERBUFFER, renderbuffer);
    }
    gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set up framebuffer object");
    TCU_CHECK(gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);

    {
        vector<uint32_t> drawBuffers(m_outputLayout.locationSymbols.size());
        for (int ndx = 0; ndx < (int)m_outputLayout.locationSymbols.size(); ndx++)
            drawBuffers[ndx] = GL_COLOR_ATTACHMENT0 + ndx;
        gl.drawBuffers((int)drawBuffers.size(), &drawBuffers[0]);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawBuffers()");
    }

    // Render
    gl.viewport(0, 0, framebufferW, framebufferH);
    glu::draw(m_renderCtx, this->getProgram(), (int)vertexArrays.size(), &vertexArrays[0], glu::pr::Points(numValues));
    GLU_EXPECT_NO_ERROR(gl.getError(), "Error in draw");

    // Read back pixels.
    {
        tcu::TextureLevel tmpBuf;

        // \todo [2013-08-07 pyry] Some fast-paths could be added here.

        for (int outNdx = 0; outNdx < (int)m_outputs.size(); ++outNdx)
        {
            const Symbol &output            = m_outputs[outNdx];
            const int outSize               = output.varType.getScalarSize();
            const int outVecSize            = glu::getDataTypeNumComponents(output.varType.getBasicType());
            const int outNumLocs            = glu::getDataTypeNumLocations(output.varType.getBasicType());
            uint32_t *dstPtrBase            = static_cast<uint32_t *>(outputs[outNdx]);
            const tcu::TextureFormat format = getRenderbufferFormatForOutput(output.varType, useIntOutputs);
            const tcu::TextureFormat readFormat(tcu::TextureFormat::RGBA, format.type);
            const int outLocation = de::lookup(m_outputLayout.locationMap, output.name);

            tmpBuf.setStorage(readFormat, framebufferW, framebufferH);

            for (int locNdx = 0; locNdx < outNumLocs; ++locNdx)
            {
                gl.readBuffer(GL_COLOR_ATTACHMENT0 + outLocation + locNdx);
                glu::readPixels(m_renderCtx, 0, 0, tmpBuf.getAccess());
                GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels");

                if (outSize == 4 && outNumLocs == 1)
                    deMemcpy(dstPtrBase, tmpBuf.getAccess().getDataPtr(), numValues * outVecSize * sizeof(uint32_t));
                else
                {
                    for (int valNdx = 0; valNdx < numValues; valNdx++)
                    {
                        const uint32_t *srcPtr = (const uint32_t *)tmpBuf.getAccess().getDataPtr() + valNdx * 4;
                        uint32_t *dstPtr       = &dstPtrBase[outSize * valNdx + outVecSize * locNdx];
                        deMemcpy(dstPtr, srcPtr, outVecSize * sizeof(uint32_t));
                    }
                }
            }
        }
    }

    // \todo [2013-08-07 pyry] Clear draw buffers & viewport?
    gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
}

// VertexShaderExecutor

class VertexShaderExecutor : public FragmentOutExecutor
{
public:
    VertexShaderExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);
    ~VertexShaderExecutor(void);

    bool isOk(void) const
    {
        return m_program.isOk();
    }
    void log(tcu::TestLog &dst) const
    {
        dst << m_program;
    }
    uint32_t getProgram(void) const
    {
        return m_program.getProgram();
    }

protected:
    const glu::ShaderProgram m_program;
};

VertexShaderExecutor::VertexShaderExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec)
    : FragmentOutExecutor(renderCtx, shaderSpec)
    , m_program(renderCtx, glu::ProgramSources()
                               << glu::VertexSource(generateVertexShader(shaderSpec, "a_", "vtx_out_"))
                               << glu::FragmentSource(
                                      generatePassthroughFragmentShader(shaderSpec, !hasFloatRenderTargets(renderCtx),
                                                                        m_outputLayout.locationMap, "vtx_out_", "o_")))
{
}

VertexShaderExecutor::~VertexShaderExecutor(void)
{
}

// GeometryShaderExecutor

class GeometryShaderExecutor : public FragmentOutExecutor
{
public:
    static GeometryShaderExecutor *create(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);

    ~GeometryShaderExecutor(void);

    bool isOk(void) const
    {
        return m_program.isOk();
    }
    void log(tcu::TestLog &dst) const
    {
        dst << m_program;
    }
    uint32_t getProgram(void) const
    {
        return m_program.getProgram();
    }

protected:
    const glu::ShaderProgram m_program;

private:
    GeometryShaderExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);
};

GeometryShaderExecutor *GeometryShaderExecutor::create(const glu::RenderContext &renderCtx,
                                                       const ShaderSpec &shaderSpec)
{
    if (glu::glslVersionIsES(shaderSpec.version) && shaderSpec.version <= glu::GLSL_VERSION_310_ES &&
        !contextSupports(renderCtx.getType(), glu::ApiType::core(4, 5)))
        checkExtension(renderCtx, "GL_EXT_geometry_shader");

    return new GeometryShaderExecutor(renderCtx, shaderSpec);
}

GeometryShaderExecutor::GeometryShaderExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec)
    : FragmentOutExecutor(renderCtx, shaderSpec)
    , m_program(renderCtx, glu::ProgramSources()
                               << glu::VertexSource(generatePassthroughVertexShader(shaderSpec, "a_", "vtx_out_"))
                               << glu::GeometrySource(generateGeometryShader(shaderSpec, "vtx_out_", "geom_out_"))
                               << glu::FragmentSource(
                                      generatePassthroughFragmentShader(shaderSpec, !hasFloatRenderTargets(renderCtx),
                                                                        m_outputLayout.locationMap, "geom_out_", "o_")))
{
}

GeometryShaderExecutor::~GeometryShaderExecutor(void)
{
}

// FragmentShaderExecutor

class FragmentShaderExecutor : public FragmentOutExecutor
{
public:
    FragmentShaderExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);
    ~FragmentShaderExecutor(void);

    bool isOk(void) const
    {
        return m_program.isOk();
    }
    void log(tcu::TestLog &dst) const
    {
        dst << m_program;
    }
    uint32_t getProgram(void) const
    {
        return m_program.getProgram();
    }

protected:
    const glu::ShaderProgram m_program;
};

FragmentShaderExecutor::FragmentShaderExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec)
    : FragmentOutExecutor(renderCtx, shaderSpec)
    , m_program(
          renderCtx, glu::ProgramSources()
                         << glu::VertexSource(generatePassthroughVertexShader(shaderSpec, "a_", "vtx_out_"))
                         << glu::FragmentSource(generateFragmentShader(shaderSpec, !hasFloatRenderTargets(renderCtx),
                                                                       m_outputLayout.locationMap, "vtx_out_", "o_")))
{
}

FragmentShaderExecutor::~FragmentShaderExecutor(void)
{
}

// Shared utilities for compute and tess executors

static uint32_t getVecStd430ByteAlignment(glu::DataType type)
{
    switch (glu::getDataTypeScalarSize(type))
    {
    case 1:
        return 4u;
    case 2:
        return 8u;
    case 3:
        return 16u;
    case 4:
        return 16u;
    default:
        DE_ASSERT(false);
        return 0u;
    }
}

class BufferIoExecutor : public ShaderExecutor
{
public:
    BufferIoExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec,
                     const glu::ProgramSources &sources);
    ~BufferIoExecutor(void);

    bool isOk(void) const
    {
        return m_program.isOk();
    }
    void log(tcu::TestLog &dst) const
    {
        dst << m_program;
    }
    uint32_t getProgram(void) const
    {
        return m_program.getProgram();
    }

protected:
    enum
    {
        INPUT_BUFFER_BINDING  = 0,
        OUTPUT_BUFFER_BINDING = 1,
    };

    void initBuffers(int numValues);
    uint32_t getInputBuffer(void) const
    {
        return *m_inputBuffer;
    }
    uint32_t getOutputBuffer(void) const
    {
        return *m_outputBuffer;
    }
    uint32_t getInputStride(void) const
    {
        return getLayoutStride(m_inputLayout);
    }
    uint32_t getOutputStride(void) const
    {
        return getLayoutStride(m_outputLayout);
    }

    void uploadInputBuffer(const void *const *inputPtrs, int numValues);
    void readOutputBuffer(void *const *outputPtrs, int numValues);

    static void declareBufferBlocks(std::ostream &src, const ShaderSpec &spec);
    static void generateExecBufferIo(std::ostream &src, const ShaderSpec &spec, const char *invocationNdxName);

    glu::ShaderProgram m_program;

private:
    struct VarLayout
    {
        uint32_t offset;
        uint32_t stride;
        uint32_t matrixStride;

        VarLayout(void) : offset(0), stride(0), matrixStride(0)
        {
        }
    };

    void resizeInputBuffer(int newSize);
    void resizeOutputBuffer(int newSize);

    static void computeVarLayout(const std::vector<Symbol> &symbols, std::vector<VarLayout> *layout);
    static uint32_t getLayoutStride(const vector<VarLayout> &layout);

    static void copyToBuffer(const glu::VarType &varType, const VarLayout &layout, int numValues,
                             const void *srcBasePtr, void *dstBasePtr);
    static void copyFromBuffer(const glu::VarType &varType, const VarLayout &layout, int numValues,
                               const void *srcBasePtr, void *dstBasePtr);

    glu::Buffer m_inputBuffer;
    glu::Buffer m_outputBuffer;

    vector<VarLayout> m_inputLayout;
    vector<VarLayout> m_outputLayout;
};

BufferIoExecutor::BufferIoExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec,
                                   const glu::ProgramSources &sources)
    : ShaderExecutor(renderCtx, shaderSpec)
    , m_program(renderCtx, sources)
    , m_inputBuffer(renderCtx)
    , m_outputBuffer(renderCtx)
{
    computeVarLayout(m_inputs, &m_inputLayout);
    computeVarLayout(m_outputs, &m_outputLayout);
}

BufferIoExecutor::~BufferIoExecutor(void)
{
}

void BufferIoExecutor::resizeInputBuffer(int newSize)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();
    gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *m_inputBuffer);
    gl.bufferData(GL_SHADER_STORAGE_BUFFER, newSize, DE_NULL, GL_STATIC_DRAW);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to allocate input buffer");
}

void BufferIoExecutor::resizeOutputBuffer(int newSize)
{
    const glw::Functions &gl = m_renderCtx.getFunctions();
    gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, *m_outputBuffer);
    gl.bufferData(GL_SHADER_STORAGE_BUFFER, newSize, DE_NULL, GL_STATIC_DRAW);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to allocate output buffer");
}

void BufferIoExecutor::initBuffers(int numValues)
{
    const uint32_t inputStride  = getLayoutStride(m_inputLayout);
    const uint32_t outputStride = getLayoutStride(m_outputLayout);
    const int inputBufferSize   = numValues * inputStride;
    const int outputBufferSize  = numValues * outputStride;

    resizeInputBuffer(inputBufferSize);
    resizeOutputBuffer(outputBufferSize);
}

void BufferIoExecutor::computeVarLayout(const std::vector<Symbol> &symbols, std::vector<VarLayout> *layout)
{
    uint32_t maxAlignment = 0;
    uint32_t curOffset    = 0;

    DE_ASSERT(layout->empty());
    layout->resize(symbols.size());

    for (size_t varNdx = 0; varNdx < symbols.size(); varNdx++)
    {
        const Symbol &symbol          = symbols[varNdx];
        const glu::DataType basicType = symbol.varType.getBasicType();
        VarLayout &layoutEntry        = (*layout)[varNdx];

        if (glu::isDataTypeScalarOrVector(basicType))
        {
            const uint32_t alignment = getVecStd430ByteAlignment(basicType);
            const uint32_t size      = (uint32_t)glu::getDataTypeScalarSize(basicType) * (int)sizeof(uint32_t);

            curOffset    = (uint32_t)deAlign32((int)curOffset, (int)alignment);
            maxAlignment = de::max(maxAlignment, alignment);

            layoutEntry.offset       = curOffset;
            layoutEntry.matrixStride = 0;

            curOffset += size;
        }
        else if (glu::isDataTypeMatrix(basicType))
        {
            const int numVecs           = glu::getDataTypeMatrixNumColumns(basicType);
            const glu::DataType vecType = glu::getDataTypeFloatVec(glu::getDataTypeMatrixNumRows(basicType));
            const uint32_t vecAlignment = getVecStd430ByteAlignment(vecType);

            curOffset    = (uint32_t)deAlign32((int)curOffset, (int)vecAlignment);
            maxAlignment = de::max(maxAlignment, vecAlignment);

            layoutEntry.offset       = curOffset;
            layoutEntry.matrixStride = vecAlignment;

            curOffset += vecAlignment * numVecs;
        }
        else
            DE_ASSERT(false);
    }

    {
        const uint32_t totalSize = (uint32_t)deAlign32(curOffset, maxAlignment);

        for (vector<VarLayout>::iterator varIter = layout->begin(); varIter != layout->end(); ++varIter)
            varIter->stride = totalSize;
    }
}

inline uint32_t BufferIoExecutor::getLayoutStride(const vector<VarLayout> &layout)
{
    return layout.empty() ? 0 : layout[0].stride;
}

void BufferIoExecutor::copyToBuffer(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 scalarSize          = glu::getDataTypeScalarSize(basicType);
        const int numVecs             = isMatrix ? glu::getDataTypeMatrixNumColumns(basicType) : 1;
        const int numComps            = scalarSize / numVecs;

        for (int elemNdx = 0; elemNdx < numValues; elemNdx++)
        {
            for (int vecNdx = 0; vecNdx < numVecs; vecNdx++)
            {
                const int srcOffset = (int)sizeof(uint32_t) * (elemNdx * scalarSize + vecNdx * numComps);
                const int dstOffset =
                    layout.offset + layout.stride * elemNdx + (isMatrix ? layout.matrixStride * vecNdx : 0);
                const uint8_t *srcPtr = (const uint8_t *)srcBasePtr + srcOffset;
                uint8_t *dstPtr       = (uint8_t *)dstBasePtr + dstOffset;

                deMemcpy(dstPtr, srcPtr, sizeof(uint32_t) * numComps);
            }
        }
    }
    else
        throw tcu::InternalError("Unsupported type");
}

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 scalarSize          = glu::getDataTypeScalarSize(basicType);
        const int numVecs             = isMatrix ? glu::getDataTypeMatrixNumColumns(basicType) : 1;
        const int numComps            = scalarSize / numVecs;

        for (int elemNdx = 0; elemNdx < numValues; elemNdx++)
        {
            for (int vecNdx = 0; vecNdx < numVecs; vecNdx++)
            {
                const int srcOffset =
                    layout.offset + layout.stride * elemNdx + (isMatrix ? layout.matrixStride * vecNdx : 0);
                const int dstOffset   = (int)sizeof(uint32_t) * (elemNdx * scalarSize + vecNdx * numComps);
                const uint8_t *srcPtr = (const uint8_t *)srcBasePtr + srcOffset;
                uint8_t *dstPtr       = (uint8_t *)dstBasePtr + dstOffset;

                deMemcpy(dstPtr, srcPtr, sizeof(uint32_t) * numComps);
            }
        }
    }
    else
        throw tcu::InternalError("Unsupported type");
}

void BufferIoExecutor::uploadInputBuffer(const void *const *inputPtrs, int numValues)
{
    const glw::Functions &gl   = m_renderCtx.getFunctions();
    const uint32_t buffer      = *m_inputBuffer;
    const uint32_t inputStride = getLayoutStride(m_inputLayout);
    const int inputBufferSize  = inputStride * numValues;

    if (inputBufferSize == 0)
        return; // No inputs

    gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
    void *mapPtr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, inputBufferSize, GL_MAP_WRITE_BIT);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
    TCU_CHECK(mapPtr);

    try
    {
        DE_ASSERT(m_inputs.size() == m_inputLayout.size());
        for (size_t inputNdx = 0; inputNdx < m_inputs.size(); ++inputNdx)
        {
            const glu::VarType &varType = m_inputs[inputNdx].varType;
            const VarLayout &layout     = m_inputLayout[inputNdx];

            copyToBuffer(varType, layout, numValues, inputPtrs[inputNdx], mapPtr);
        }
    }
    catch (...)
    {
        gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
        throw;
    }

    gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()");
}

void BufferIoExecutor::readOutputBuffer(void *const *outputPtrs, int numValues)
{
    const glw::Functions &gl    = m_renderCtx.getFunctions();
    const uint32_t buffer       = *m_outputBuffer;
    const uint32_t outputStride = getLayoutStride(m_outputLayout);
    const int outputBufferSize  = numValues * outputStride;

    DE_ASSERT(outputBufferSize > 0); // At least some outputs are required.

    gl.memoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
    gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, buffer);
    void *mapPtr = gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, outputBufferSize, GL_MAP_READ_BIT);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange()");
    TCU_CHECK(mapPtr);

    try
    {
        DE_ASSERT(m_outputs.size() == m_outputLayout.size());
        for (size_t outputNdx = 0; outputNdx < m_outputs.size(); ++outputNdx)
        {
            const glu::VarType &varType = m_outputs[outputNdx].varType;
            const VarLayout &layout     = m_outputLayout[outputNdx];

            copyFromBuffer(varType, layout, numValues, mapPtr, outputPtrs[outputNdx]);
        }
    }
    catch (...)
    {
        gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
        throw;
    }

    gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer()");
}

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->name.c_str(), symIter->varType);
        src << glu::declare(&inputStruct) << ";\n";
    }

    // Output struct
    {
        glu::StructType outputStruct("Outputs");
        for (vector<Symbol>::const_iterator symIter = spec.outputs.begin(); symIter != spec.outputs.end(); ++symIter)
            outputStruct.addMember(symIter->name.c_str(), symIter->varType);
        src << glu::declare(&outputStruct) << ";\n";
    }

    src << "\n";

    if (!spec.inputs.empty())
    {
        src << "layout(binding = " << int(INPUT_BUFFER_BINDING) << ", std430) buffer InBuffer\n"
            << "{\n"
            << "    Inputs inputs[];\n"
            << "};\n";
    }

    src << "layout(binding = " << int(OUTPUT_BUFFER_BINDING) << ", std430) buffer OutBuffer\n"
        << "{\n"
        << "    Outputs outputs[];\n"
        << "};\n"
        << "\n";
}

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[" << invocationNdxName << "]."
            << symIter->name << ";\n";

    for (vector<Symbol>::const_iterator symIter = spec.outputs.begin(); symIter != spec.outputs.end(); ++symIter)
        src << "\t" << glu::declare(symIter->varType, symIter->name) << ";\n";

    src << "\n";

    {
        std::istringstream opSrc(spec.source);
        std::string line;

        while (std::getline(opSrc, line))
            src << "\t" << line << "\n";
    }

    src << "\n";
    for (vector<Symbol>::const_iterator symIter = spec.outputs.begin(); symIter != spec.outputs.end(); ++symIter)
        src << "\toutputs[" << invocationNdxName << "]." << symIter->name << " = " << symIter->name << ";\n";
}

// ComputeShaderExecutor

class ComputeShaderExecutor : public BufferIoExecutor
{
public:
    ComputeShaderExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);
    ~ComputeShaderExecutor(void);

    void execute(int numValues, const void *const *inputs, void *const *outputs);

protected:
    static std::string generateComputeShader(const ShaderSpec &spec);

    tcu::IVec3 m_maxWorkSize;
};

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";

    declareBufferBlocks(src, spec);

    src << "void main (void)\n"
        << "{\n"
        << "    uint invocationNdx = gl_NumWorkGroups.x*gl_NumWorkGroups.y*gl_WorkGroupID.z\n"
        << "                       + gl_NumWorkGroups.x*gl_WorkGroupID.y + gl_WorkGroupID.x;\n";

    generateExecBufferIo(src, spec, "invocationNdx");

    src << "}\n";

    return src.str();
}

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
}

ComputeShaderExecutor::~ComputeShaderExecutor(void)
{
}

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 uint32_t inputStride       = getInputStride();
    const uint32_t outputStride      = getOutputStride();

    initBuffers(numValues);

    // Setup input buffer & copy data
    uploadInputBuffer(inputs, numValues);

    // Perform compute invocations
    {
        int curOffset = 0;
        while (curOffset < numValues)
        {
            const int numToExec = de::min(maxValuesPerInvocation, numValues - curOffset);

            if (inputStride > 0)
                gl.bindBufferRange(GL_SHADER_STORAGE_BUFFER, INPUT_BUFFER_BINDING, getInputBuffer(),
                                   curOffset * inputStride, numToExec * inputStride);

            gl.bindBufferRange(GL_SHADER_STORAGE_BUFFER, OUTPUT_BUFFER_BINDING, getOutputBuffer(),
                               curOffset * outputStride, numToExec * outputStride);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferRange(GL_SHADER_STORAGE_BUFFER)");

            gl.dispatchCompute(numToExec, 1, 1);
            GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute()");

            curOffset += numToExec;
        }
    }

    // Read back data
    readOutputBuffer(outputs, numValues);
}

// Tessellation utils

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();
}

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 &&
        !contextSupports(renderCtx.getType(), glu::ApiType::core(4, 5)))
        checkExtension(renderCtx, "GL_EXT_tessellation_shader");

    if (stage == glu::SHADERTYPE_TESSELLATION_CONTROL)
        checkLimit(renderCtx, GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS, numBlockRequired);
    else if (stage == glu::SHADERTYPE_TESSELLATION_EVALUATION)
        checkLimit(renderCtx, GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS, numBlockRequired);
    else
        DE_ASSERT(false);
}

// TessControlExecutor

class TessControlExecutor : public BufferIoExecutor
{
public:
    static TessControlExecutor *create(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);

    ~TessControlExecutor(void);

    void execute(int numValues, const void *const *inputs, void *const *outputs);

protected:
    static std::string generateTessControlShader(const ShaderSpec &shaderSpec);

private:
    TessControlExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);
};

TessControlExecutor *TessControlExecutor::create(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec)
{
    checkTessSupport(renderCtx, shaderSpec, glu::SHADERTYPE_TESSELLATION_CONTROL);

    return new TessControlExecutor(renderCtx, shaderSpec);
}

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_tessellation_shader : require\n";

    if (!shaderSpec.globalDeclarations.empty())
        src << shaderSpec.globalDeclarations << "\n";

    src << "\nlayout(vertices = 1) out;\n\n";

    declareBufferBlocks(src, shaderSpec);

    src << "void main (void)\n{\n";

    for (int ndx = 0; ndx < 2; ndx++)
        src << "\tgl_TessLevelInner[" << ndx << "] = 1.0;\n";

    for (int ndx = 0; ndx < 4; ndx++)
        src << "\tgl_TessLevelOuter[" << ndx << "] = 1.0;\n";

    src << "\n"
        << "\thighp uint invocationId = uint(gl_PrimitiveID);\n";

    generateExecBufferIo(src, shaderSpec, "invocationId");

    src << "}\n";

    return src.str();
}

static std::string generateEmptyTessEvalShader(glu::GLSLVersion version)
{
    std::ostringstream src;

    src << glu::getGLSLVersionDeclaration(version) << "\n";

    if (glu::glslVersionIsES(version) && version <= glu::GLSL_VERSION_310_ES)
        src << "#extension GL_EXT_tessellation_shader : require\n\n";

    src << "layout(triangles, ccw) in;\n";

    src << "\nvoid main (void)\n{\n"
        << "\tgl_Position = vec4(gl_TessCoord.xy, 0.0, 1.0);\n"
        << "}\n";

    return src.str();
}

TessControlExecutor::TessControlExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec)
    : BufferIoExecutor(renderCtx, shaderSpec,
                       glu::ProgramSources()
                           << glu::VertexSource(generateVertexShaderForTess(shaderSpec.version))
                           << glu::TessellationControlSource(generateTessControlShader(shaderSpec))
                           << glu::TessellationEvaluationSource(generateEmptyTessEvalShader(shaderSpec.version))
                           << glu::FragmentSource(generateEmptyFragmentSource(shaderSpec.version)))
{
}

TessControlExecutor::~TessControlExecutor(void)
{
}

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_BUFFER, INPUT_BUFFER_BINDING, getInputBuffer());

    gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, OUTPUT_BUFFER_BINDING, getOutputBuffer());

    uint32_t vertexArray;
    gl.genVertexArrays(1, &vertexArray);
    gl.bindVertexArray(vertexArray);

    // Render patches
    gl.patchParameteri(GL_PATCH_VERTICES, 3);
    gl.drawArrays(GL_PATCHES, 0, 3 * numValues);

    gl.bindVertexArray(0);
    gl.deleteVertexArrays(1, &vertexArray);

    // Read back data
    readOutputBuffer(outputs, numValues);
}

// TessEvaluationExecutor

class TessEvaluationExecutor : public BufferIoExecutor
{
public:
    static TessEvaluationExecutor *create(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);

    ~TessEvaluationExecutor(void);

    void execute(int numValues, const void *const *inputs, void *const *outputs);

protected:
    static std::string generateTessEvalShader(const ShaderSpec &shaderSpec);

private:
    TessEvaluationExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec);
};

TessEvaluationExecutor *TessEvaluationExecutor::create(const glu::RenderContext &renderCtx,
                                                       const ShaderSpec &shaderSpec)
{
    checkTessSupport(renderCtx, shaderSpec, glu::SHADERTYPE_TESSELLATION_EVALUATION);

    return new TessEvaluationExecutor(renderCtx, shaderSpec);
}

static std::string generatePassthroughTessControlShader(glu::GLSLVersion version)
{
    std::ostringstream src;

    src << glu::getGLSLVersionDeclaration(version) << "\n";

    if (glu::glslVersionIsES(version) && version <= glu::GLSL_VERSION_310_ES)
        src << "#extension GL_EXT_tessellation_shader : require\n\n";

    src << "layout(vertices = 1) out;\n\n";

    src << "void main (void)\n{\n";

    for (int ndx = 0; ndx < 2; ndx++)
        src << "\tgl_TessLevelInner[" << ndx << "] = 1.0;\n";

    for (int ndx = 0; ndx < 4; ndx++)
        src << "\tgl_TessLevelOuter[" << ndx << "] = 1.0;\n";

    src << "}\n";

    return src.str();
}

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_tessellation_shader : require\n";

    if (!shaderSpec.globalDeclarations.empty())
        src << shaderSpec.globalDeclarations << "\n";

    src << "\n";

    src << "layout(isolines, equal_spacing) in;\n\n";

    declareBufferBlocks(src, shaderSpec);

    src << "void main (void)\n{\n"
        << "\tgl_Position = vec4(gl_TessCoord.x, 0.0, 0.0, 1.0);\n"
        << "\thighp uint invocationId = uint(gl_PrimitiveID)*2u + (gl_TessCoord.x > 0.5 ? 1u : 0u);\n";

    generateExecBufferIo(src, shaderSpec, "invocationId");

    src << "}\n";

    return src.str();
}

TessEvaluationExecutor::TessEvaluationExecutor(const glu::RenderContext &renderCtx, const ShaderSpec &shaderSpec)
    : BufferIoExecutor(renderCtx, shaderSpec,
                       glu::ProgramSources()
                           << glu::VertexSource(generateVertexShaderForTess(shaderSpec.version))
                           << glu::TessellationControlSource(generatePassthroughTessControlShader(shaderSpec.version))
                           << glu::TessellationEvaluationSource(generateTessEvalShader(shaderSpec))
                           << glu::FragmentSource(generateEmptyFragmentSource(shaderSpec.version)))
{
}

TessEvaluationExecutor::~TessEvaluationExecutor(void)
{
}

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);

    // Setup input buffer & copy data
    uploadInputBuffer(inputs, numValues);

    // \todo [2014-06-26 pyry] Duplicate last value in the buffer to prevent infinite loops for example?

    if (!m_inputs.empty())
        gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, INPUT_BUFFER_BINDING, getInputBuffer());

    gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, OUTPUT_BUFFER_BINDING, getOutputBuffer());

    uint32_t vertexArray;
    gl.genVertexArrays(1, &vertexArray);
    gl.bindVertexArray(vertexArray);

    // Render patches
    gl.patchParameteri(GL_PATCH_VERTICES, 2);
    gl.drawArrays(GL_PATCHES, 0, alignedValues);

    gl.bindVertexArray(0);
    gl.deleteVertexArrays(1, &vertexArray);

    // Read back data
    readOutputBuffer(outputs, numValues);
}

// Utilities

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::create(renderCtx, shaderSpec);
    case glu::SHADERTYPE_TESSELLATION_EVALUATION:
        return TessEvaluationExecutor::create(renderCtx, shaderSpec);
    case glu::SHADERTYPE_GEOMETRY:
        return GeometryShaderExecutor::create(renderCtx, shaderSpec);
    case glu::SHADERTYPE_FRAGMENT:
        return new FragmentShaderExecutor(renderCtx, shaderSpec);
    case glu::SHADERTYPE_COMPUTE:
        return new ComputeShaderExecutor(renderCtx, shaderSpec);
    default:
        throw tcu::InternalError("Unsupported shader type");
    }
}

bool executorSupported(glu::ShaderType shaderType)
{
    switch (shaderType)
    {
    case glu::SHADERTYPE_VERTEX:
    case glu::SHADERTYPE_TESSELLATION_CONTROL:
    case glu::SHADERTYPE_TESSELLATION_EVALUATION:
    case glu::SHADERTYPE_GEOMETRY:
    case glu::SHADERTYPE_FRAGMENT:
    case glu::SHADERTYPE_COMPUTE:
        return true;
    default:
        return false;
    }
}

} // namespace ShaderExecUtil
} // namespace gls
} // namespace deqp