src/compiler/translator/OutputHLSL.cpp

//
// Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

#include "compiler/translator/OutputHLSL.h"

#include <stdio.h>
#include <algorithm>
#include <cfloat>

#include "common/angleutils.h"
#include "common/debug.h"
#include "common/utilities.h"
#include "compiler/translator/AtomicCounterFunctionHLSL.h"
#include "compiler/translator/BuiltInFunctionEmulator.h"
#include "compiler/translator/BuiltInFunctionEmulatorHLSL.h"
#include "compiler/translator/ImageFunctionHLSL.h"
#include "compiler/translator/InfoSink.h"
#include "compiler/translator/ResourcesHLSL.h"
#include "compiler/translator/StructureHLSL.h"
#include "compiler/translator/TextureFunctionHLSL.h"
#include "compiler/translator/TranslatorHLSL.h"
#include "compiler/translator/UtilsHLSL.h"
#include "compiler/translator/blocklayout.h"
#include "compiler/translator/tree_ops/RemoveSwitchFallThrough.h"
#include "compiler/translator/tree_util/FindSymbolNode.h"
#include "compiler/translator/tree_util/NodeSearch.h"
#include "compiler/translator/util.h"

namespace sh
{

namespace
{

TString ArrayHelperFunctionName(const char *prefix, const TType &type)
{
    TStringStream fnName;
    fnName << prefix << "_";
    if (type.isArray())
    {
        for (unsigned int arraySize : *type.getArraySizes())
        {
            fnName << arraySize << "_";
        }
    }
    fnName << TypeString(type);
    return fnName.str();
}

bool IsDeclarationWrittenOut(TIntermDeclaration *node)
{
    TIntermSequence *sequence = node->getSequence();
    TIntermTyped *variable    = (*sequence)[0]->getAsTyped();
    ASSERT(sequence->size() == 1);
    ASSERT(variable);
    return (variable->getQualifier() == EvqTemporary || variable->getQualifier() == EvqGlobal ||
            variable->getQualifier() == EvqConst || variable->getQualifier() == EvqShared);
}

bool IsInStd140UniformBlock(TIntermTyped *node)
{
    TIntermBinary *binaryNode = node->getAsBinaryNode();

    if (binaryNode)
    {
        return IsInStd140UniformBlock(binaryNode->getLeft());
    }

    const TType &type = node->getType();

    if (type.getQualifier() == EvqUniform)
    {
        // determine if we are in the standard layout
        const TInterfaceBlock *interfaceBlock = type.getInterfaceBlock();
        if (interfaceBlock)
        {
            return (interfaceBlock->blockStorage() == EbsStd140);
        }
    }

    return false;
}

const char *GetHLSLAtomicFunctionStringAndLeftParenthesis(TOperator op)
{
    switch (op)
    {
        case EOpAtomicAdd:
            return "InterlockedAdd(";
        case EOpAtomicMin:
            return "InterlockedMin(";
        case EOpAtomicMax:
            return "InterlockedMax(";
        case EOpAtomicAnd:
            return "InterlockedAnd(";
        case EOpAtomicOr:
            return "InterlockedOr(";
        case EOpAtomicXor:
            return "InterlockedXor(";
        case EOpAtomicExchange:
            return "InterlockedExchange(";
        case EOpAtomicCompSwap:
            return "InterlockedCompareExchange(";
        default:
            UNREACHABLE();
            return "";
    }
}

bool IsAtomicFunctionDirectAssign(const TIntermBinary &node)
{
    return node.getOp() == EOpAssign && node.getRight()->getAsAggregate() &&
           IsAtomicFunction(node.getRight()->getAsAggregate()->getOp());
}

const char *kZeros       = "_ANGLE_ZEROS_";
constexpr int kZeroCount = 256;
std::string DefineZeroArray()
{
    std::stringstream ss;
    // For 'static', if the declaration does not include an initializer, the value is set to zero.
    // https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-variable-syntax
    ss << "static uint " << kZeros << "[" << kZeroCount << "];\n";
    return ss.str();
}

std::string GetZeroInitializer(size_t size)
{
    std::stringstream ss;
    size_t quotient = size / kZeroCount;
    size_t reminder = size % kZeroCount;

    for (size_t i = 0; i < quotient; ++i)
    {
        if (i != 0)
        {
            ss << ", ";
        }
        ss << kZeros;
    }

    for (size_t i = 0; i < reminder; ++i)
    {
        if (quotient != 0 || i != 0)
        {
            ss << ", ";
        }
        ss << "0";
    }

    return ss.str();
}

}  // anonymous namespace

TReferencedBlock::TReferencedBlock(const TInterfaceBlock *aBlock,
                                   const TVariable *aInstanceVariable)
    : block(aBlock), instanceVariable(aInstanceVariable)
{}

void OutputHLSL::writeFloat(TInfoSinkBase &out, float f)
{
    // This is known not to work for NaN on all drivers but make the best effort to output NaNs
    // regardless.
    if ((gl::isInf(f) || gl::isNaN(f)) && mShaderVersion >= 300 &&
        mOutputType == SH_HLSL_4_1_OUTPUT)
    {
        out << "asfloat(" << gl::bitCast<uint32_t>(f) << "u)";
    }
    else
    {
        out << std::min(FLT_MAX, std::max(-FLT_MAX, f));
    }
}

void OutputHLSL::writeSingleConstant(TInfoSinkBase &out, const TConstantUnion *const constUnion)
{
    ASSERT(constUnion != nullptr);
    switch (constUnion->getType())
    {
        case EbtFloat:
            writeFloat(out, constUnion->getFConst());
            break;
        case EbtInt:
            out << constUnion->getIConst();
            break;
        case EbtUInt:
            out << constUnion->getUConst();
            break;
        case EbtBool:
            out << constUnion->getBConst();
            break;
        default:
            UNREACHABLE();
    }
}

const TConstantUnion *OutputHLSL::writeConstantUnionArray(TInfoSinkBase &out,
                                                          const TConstantUnion *const constUnion,
                                                          const size_t size)
{
    const TConstantUnion *constUnionIterated = constUnion;
    for (size_t i = 0; i < size; i++, constUnionIterated++)
    {
        writeSingleConstant(out, constUnionIterated);

        if (i != size - 1)
        {
            out << ", ";
        }
    }
    return constUnionIterated;
}

OutputHLSL::OutputHLSL(sh::GLenum shaderType,
                       int shaderVersion,
                       const TExtensionBehavior &extensionBehavior,
                       const char *sourcePath,
                       ShShaderOutput outputType,
                       int numRenderTargets,
                       const std::vector<Uniform> &uniforms,
                       ShCompileOptions compileOptions,
                       sh::WorkGroupSize workGroupSize,
                       TSymbolTable *symbolTable,
                       PerformanceDiagnostics *perfDiagnostics)
    : TIntermTraverser(true, true, true, symbolTable),
      mShaderType(shaderType),
      mShaderVersion(shaderVersion),
      mExtensionBehavior(extensionBehavior),
      mSourcePath(sourcePath),
      mOutputType(outputType),
      mCompileOptions(compileOptions),
      mInsideFunction(false),
      mInsideMain(false),
      mNumRenderTargets(numRenderTargets),
      mCurrentFunctionMetadata(nullptr),
      mWorkGroupSize(workGroupSize),
      mPerfDiagnostics(perfDiagnostics)
{
    mUsesFragColor   = false;
    mUsesFragData    = false;
    mUsesDepthRange  = false;
    mUsesFragCoord   = false;
    mUsesPointCoord  = false;
    mUsesFrontFacing = false;
    mUsesPointSize   = false;
    mUsesInstanceID  = false;
    mHasMultiviewExtensionEnabled =
        IsExtensionEnabled(mExtensionBehavior, TExtension::OVR_multiview);
    mUsesViewID                  = false;
    mUsesVertexID                = false;
    mUsesFragDepth               = false;
    mUsesNumWorkGroups           = false;
    mUsesWorkGroupID             = false;
    mUsesLocalInvocationID       = false;
    mUsesGlobalInvocationID      = false;
    mUsesLocalInvocationIndex    = false;
    mUsesXor                     = false;
    mUsesDiscardRewriting        = false;
    mUsesNestedBreak             = false;
    mRequiresIEEEStrictCompiling = false;
    mUseZeroArray                = false;

    mUniqueIndex = 0;

    mOutputLod0Function      = false;
    mInsideDiscontinuousLoop = false;
    mNestedLoopDepth         = 0;

    mExcessiveLoopIndex = nullptr;

    mStructureHLSL             = new StructureHLSL;
    mTextureFunctionHLSL       = new TextureFunctionHLSL;
    mImageFunctionHLSL         = new ImageFunctionHLSL;
    mAtomicCounterFunctionHLSL = new AtomicCounterFunctionHLSL;

    unsigned int firstUniformRegister =
        ((compileOptions & SH_SKIP_D3D_CONSTANT_REGISTER_ZERO) != 0) ? 1u : 0u;
    mResourcesHLSL = new ResourcesHLSL(mStructureHLSL, outputType, uniforms, firstUniformRegister);

    if (mOutputType == SH_HLSL_3_0_OUTPUT)
    {
        // Fragment shaders need dx_DepthRange, dx_ViewCoords and dx_DepthFront.
        // Vertex shaders need a slightly different set: dx_DepthRange, dx_ViewCoords and
        // dx_ViewAdjust.
        // In both cases total 3 uniform registers need to be reserved.
        mResourcesHLSL->reserveUniformRegisters(3);
    }

    // Reserve registers for the default uniform block and driver constants
    mResourcesHLSL->reserveUniformBlockRegisters(2);

    mSSBOOutputHLSL = new ShaderStorageBlockOutputHLSL(this, symbolTable, mResourcesHLSL);
}

OutputHLSL::~OutputHLSL()
{
    SafeDelete(mSSBOOutputHLSL);
    SafeDelete(mStructureHLSL);
    SafeDelete(mResourcesHLSL);
    SafeDelete(mTextureFunctionHLSL);
    SafeDelete(mImageFunctionHLSL);
    SafeDelete(mAtomicCounterFunctionHLSL);
    for (auto &eqFunction : mStructEqualityFunctions)
    {
        SafeDelete(eqFunction);
    }
    for (auto &eqFunction : mArrayEqualityFunctions)
    {
        SafeDelete(eqFunction);
    }
}

void OutputHLSL::output(TIntermNode *treeRoot, TInfoSinkBase &objSink)
{
    BuiltInFunctionEmulator builtInFunctionEmulator;
    InitBuiltInFunctionEmulatorForHLSL(&builtInFunctionEmulator);
    if ((mCompileOptions & SH_EMULATE_ISNAN_FLOAT_FUNCTION) != 0)
    {
        InitBuiltInIsnanFunctionEmulatorForHLSLWorkarounds(&builtInFunctionEmulator,
                                                           mShaderVersion);
    }

    builtInFunctionEmulator.markBuiltInFunctionsForEmulation(treeRoot);

    // Now that we are done changing the AST, do the analyses need for HLSL generation
    CallDAG::InitResult success = mCallDag.init(treeRoot, nullptr);
    ASSERT(success == CallDAG::INITDAG_SUCCESS);
    mASTMetadataList = CreateASTMetadataHLSL(treeRoot, mCallDag);

    const std::vector<MappedStruct> std140Structs = FlagStd140Structs(treeRoot);
    // TODO(oetuaho): The std140Structs could be filtered based on which ones actually get used in
    // the shader code. When we add shader storage blocks we might also consider an alternative
    // solution, since the struct mapping won't work very well for shader storage blocks.

    // Output the body and footer first to determine what has to go in the header
    mInfoSinkStack.push(&mBody);
    treeRoot->traverse(this);
    mInfoSinkStack.pop();

    mInfoSinkStack.push(&mFooter);
    mInfoSinkStack.pop();

    mInfoSinkStack.push(&mHeader);
    header(mHeader, std140Structs, &builtInFunctionEmulator);
    mInfoSinkStack.pop();

    objSink << mHeader.c_str();
    objSink << mBody.c_str();
    objSink << mFooter.c_str();

    builtInFunctionEmulator.cleanup();
}

const std::map<std::string, unsigned int> &OutputHLSL::getShaderStorageBlockRegisterMap() const
{
    return mResourcesHLSL->getShaderStorageBlockRegisterMap();
}

const std::map<std::string, unsigned int> &OutputHLSL::getUniformBlockRegisterMap() const
{
    return mResourcesHLSL->getUniformBlockRegisterMap();
}

const std::map<std::string, unsigned int> &OutputHLSL::getUniformRegisterMap() const
{
    return mResourcesHLSL->getUniformRegisterMap();
}

TString OutputHLSL::structInitializerString(int indent,
                                            const TType &type,
                                            const TString &name) const
{
    TString init;

    TString indentString;
    for (int spaces = 0; spaces < indent; spaces++)
    {
        indentString += "    ";
    }

    if (type.isArray())
    {
        init += indentString + "{\n";
        for (unsigned int arrayIndex = 0u; arrayIndex < type.getOutermostArraySize(); ++arrayIndex)
        {
            TStringStream indexedString;
            indexedString << name << "[" << arrayIndex << "]";
            TType elementType = type;
            elementType.toArrayElementType();
            init += structInitializerString(indent + 1, elementType, indexedString.str());
            if (arrayIndex < type.getOutermostArraySize() - 1)
            {
                init += ",";
            }
            init += "\n";
        }
        init += indentString + "}";
    }
    else if (type.getBasicType() == EbtStruct)
    {
        init += indentString + "{\n";
        const TStructure &structure = *type.getStruct();
        const TFieldList &fields    = structure.fields();
        for (unsigned int fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++)
        {
            const TField &field      = *fields[fieldIndex];
            const TString &fieldName = name + "." + Decorate(field.name());
            const TType &fieldType   = *field.type();

            init += structInitializerString(indent + 1, fieldType, fieldName);
            if (fieldIndex < fields.size() - 1)
            {
                init += ",";
            }
            init += "\n";
        }
        init += indentString + "}";
    }
    else
    {
        init += indentString + name;
    }

    return init;
}

TString OutputHLSL::generateStructMapping(const std::vector<MappedStruct> &std140Structs) const
{
    TString mappedStructs;

    for (auto &mappedStruct : std140Structs)
    {
        const TInterfaceBlock *interfaceBlock =
            mappedStruct.blockDeclarator->getType().getInterfaceBlock();
        TQualifier qualifier = mappedStruct.blockDeclarator->getType().getQualifier();
        switch (qualifier)
        {
            case EvqUniform:
                if (mReferencedUniformBlocks.count(interfaceBlock->uniqueId().get()) == 0)
                {
                    continue;
                }
                break;
            case EvqBuffer:
                continue;
            default:
                UNREACHABLE();
                return mappedStructs;
        }

        unsigned int instanceCount = 1u;
        bool isInstanceArray       = mappedStruct.blockDeclarator->isArray();
        if (isInstanceArray)
        {
            instanceCount = mappedStruct.blockDeclarator->getOutermostArraySize();
        }

        for (unsigned int instanceArrayIndex = 0; instanceArrayIndex < instanceCount;
             ++instanceArrayIndex)
        {
            TString originalName;
            TString mappedName("map");

            if (mappedStruct.blockDeclarator->variable().symbolType() != SymbolType::Empty)
            {
                const ImmutableString &instanceName =
                    mappedStruct.blockDeclarator->variable().name();
                unsigned int instanceStringArrayIndex = GL_INVALID_INDEX;
                if (isInstanceArray)
                    instanceStringArrayIndex = instanceArrayIndex;
                TString instanceString = mResourcesHLSL->InterfaceBlockInstanceString(
                    instanceName, instanceStringArrayIndex);
                originalName += instanceString;
                mappedName += instanceString;
                originalName += ".";
                mappedName += "_";
            }

            TString fieldName = Decorate(mappedStruct.field->name());
            originalName += fieldName;
            mappedName += fieldName;

            TType *structType = mappedStruct.field->type();
            mappedStructs +=
                "static " + Decorate(structType->getStruct()->name()) + " " + mappedName;

            if (structType->isArray())
            {
                mappedStructs += ArrayString(*mappedStruct.field->type()).data();
            }

            mappedStructs += " =\n";
            mappedStructs += structInitializerString(0, *structType, originalName);
            mappedStructs += ";\n";
        }
    }
    return mappedStructs;
}

void OutputHLSL::writeReferencedAttributes(TInfoSinkBase &out) const
{
    for (const auto &attribute : mReferencedAttributes)
    {
        const TType &type           = attribute.second->getType();
        const ImmutableString &name = attribute.second->name();

        out << "static " << TypeString(type) << " " << Decorate(name) << ArrayString(type) << " = "
            << zeroInitializer(type) << ";\n";
    }
}

void OutputHLSL::writeReferencedVaryings(TInfoSinkBase &out) const
{
    for (const auto &varying : mReferencedVaryings)
    {
        const TType &type = varying.second->getType();

        // Program linking depends on this exact format
        out << "static " << InterpolationString(type.getQualifier()) << " " << TypeString(type)
            << " " << DecorateVariableIfNeeded(*varying.second) << ArrayString(type) << " = "
            << zeroInitializer(type) << ";\n";
    }
}

void OutputHLSL::header(TInfoSinkBase &out,
                        const std::vector<MappedStruct> &std140Structs,
                        const BuiltInFunctionEmulator *builtInFunctionEmulator) const
{
    TString mappedStructs = generateStructMapping(std140Structs);

    out << mStructureHLSL->structsHeader();

    mResourcesHLSL->uniformsHeader(out, mOutputType, mReferencedUniforms, mSymbolTable);
    out << mResourcesHLSL->uniformBlocksHeader(mReferencedUniformBlocks);
    mSSBOOutputHLSL->writeShaderStorageBlocksHeader(out);

    if (!mEqualityFunctions.empty())
    {
        out << "\n// Equality functions\n\n";
        for (const auto &eqFunction : mEqualityFunctions)
        {
            out << eqFunction->functionDefinition << "\n";
        }
    }
    if (!mArrayAssignmentFunctions.empty())
    {
        out << "\n// Assignment functions\n\n";
        for (const auto &assignmentFunction : mArrayAssignmentFunctions)
        {
            out << assignmentFunction.functionDefinition << "\n";
        }
    }
    if (!mArrayConstructIntoFunctions.empty())
    {
        out << "\n// Array constructor functions\n\n";
        for (const auto &constructIntoFunction : mArrayConstructIntoFunctions)
        {
            out << constructIntoFunction.functionDefinition << "\n";
        }
    }

    if (mUsesDiscardRewriting)
    {
        out << "#define ANGLE_USES_DISCARD_REWRITING\n";
    }

    if (mUsesNestedBreak)
    {
        out << "#define ANGLE_USES_NESTED_BREAK\n";
    }

    if (mRequiresIEEEStrictCompiling)
    {
        out << "#define ANGLE_REQUIRES_IEEE_STRICT_COMPILING\n";
    }

    out << "#ifdef ANGLE_ENABLE_LOOP_FLATTEN\n"
           "#define LOOP [loop]\n"
           "#define FLATTEN [flatten]\n"
           "#else\n"
           "#define LOOP\n"
           "#define FLATTEN\n"
           "#endif\n";

    // array stride for atomic counter buffers is always 4 per original extension
    // ARB_shader_atomic_counters and discussion on
    // https://github.com/KhronosGroup/OpenGL-API/issues/5
    out << "\n#define ATOMIC_COUNTER_ARRAY_STRIDE 4\n\n";

    if (mUseZeroArray)
    {
        out << DefineZeroArray() << "\n";
    }

    if (mShaderType == GL_FRAGMENT_SHADER)
    {
        const bool usingMRTExtension =
            IsExtensionEnabled(mExtensionBehavior, TExtension::EXT_draw_buffers);

        out << "// Varyings\n";
        writeReferencedVaryings(out);
        out << "\n";

        if (mShaderVersion >= 300)
        {
            for (const auto &outputVariable : mReferencedOutputVariables)
            {
                const ImmutableString &variableName = outputVariable.second->name();
                const TType &variableType           = outputVariable.second->getType();

                out << "static " << TypeString(variableType) << " out_" << variableName
                    << ArrayString(variableType) << " = " << zeroInitializer(variableType) << ";\n";
            }
        }
        else
        {
            const unsigned int numColorValues = usingMRTExtension ? mNumRenderTargets : 1;

            out << "static float4 gl_Color[" << numColorValues
                << "] =\n"
                   "{\n";
            for (unsigned int i = 0; i < numColorValues; i++)
            {
                out << "    float4(0, 0, 0, 0)";
                if (i + 1 != numColorValues)
                {
                    out << ",";
                }
                out << "\n";
            }

            out << "};\n";
        }

        if (mUsesFragDepth)
        {
            out << "static float gl_Depth = 0.0;\n";
        }

        if (mUsesFragCoord)
        {
            out << "static float4 gl_FragCoord = float4(0, 0, 0, 0);\n";
        }

        if (mUsesPointCoord)
        {
            out << "static float2 gl_PointCoord = float2(0.5, 0.5);\n";
        }

        if (mUsesFrontFacing)
        {
            out << "static bool gl_FrontFacing = false;\n";
        }

        out << "\n";

        if (mUsesDepthRange)
        {
            out << "struct gl_DepthRangeParameters\n"
                   "{\n"
                   "    float near;\n"
                   "    float far;\n"
                   "    float diff;\n"
                   "};\n"
                   "\n";
        }

        if (mOutputType == SH_HLSL_4_1_OUTPUT || mOutputType == SH_HLSL_4_0_FL9_3_OUTPUT)
        {
            out << "cbuffer DriverConstants : register(b1)\n"
                   "{\n";

            if (mUsesDepthRange)
            {
                out << "    float3 dx_DepthRange : packoffset(c0);\n";
            }

            if (mUsesFragCoord)
            {
                out << "    float4 dx_ViewCoords : packoffset(c1);\n";
            }

            if (mUsesFragCoord || mUsesFrontFacing)
            {
                out << "    float3 dx_DepthFront : packoffset(c2);\n";
            }

            if (mUsesFragCoord)
            {
                // dx_ViewScale is only used in the fragment shader to correct
                // the value for glFragCoord if necessary
                out << "    float2 dx_ViewScale : packoffset(c3);\n";
            }

            if (mHasMultiviewExtensionEnabled)
            {
                // We have to add a value which we can use to keep track of which multi-view code
                // path is to be selected in the GS.
                out << "    float multiviewSelectViewportIndex : packoffset(c3.z);\n";
            }

            if (mOutputType == SH_HLSL_4_1_OUTPUT)
            {
                mResourcesHLSL->samplerMetadataUniforms(out, "c4");
            }

            out << "};\n";
        }
        else
        {
            if (mUsesDepthRange)
            {
                out << "uniform float3 dx_DepthRange : register(c0);";
            }

            if (mUsesFragCoord)
            {
                out << "uniform float4 dx_ViewCoords : register(c1);\n";
            }

            if (mUsesFragCoord || mUsesFrontFacing)
            {
                out << "uniform float3 dx_DepthFront : register(c2);\n";
            }
        }

        out << "\n";

        if (mUsesDepthRange)
        {
            out << "static gl_DepthRangeParameters gl_DepthRange = {dx_DepthRange.x, "
                   "dx_DepthRange.y, dx_DepthRange.z};\n"
                   "\n";
        }

        if (usingMRTExtension && mNumRenderTargets > 1)
        {
            out << "#define GL_USES_MRT\n";
        }

        if (mUsesFragColor)
        {
            out << "#define GL_USES_FRAG_COLOR\n";
        }

        if (mUsesFragData)
        {
            out << "#define GL_USES_FRAG_DATA\n";
        }
    }
    else if (mShaderType == GL_VERTEX_SHADER)
    {
        out << "// Attributes\n";
        writeReferencedAttributes(out);
        out << "\n"
               "static float4 gl_Position = float4(0, 0, 0, 0);\n";

        if (mUsesPointSize)
        {
            out << "static float gl_PointSize = float(1);\n";
        }

        if (mUsesInstanceID)
        {
            out << "static int gl_InstanceID;";
        }

        if (mUsesVertexID)
        {
            out << "static int gl_VertexID;";
        }

        out << "\n"
               "// Varyings\n";
        writeReferencedVaryings(out);
        out << "\n";

        if (mUsesDepthRange)
        {
            out << "struct gl_DepthRangeParameters\n"
                   "{\n"
                   "    float near;\n"
                   "    float far;\n"
                   "    float diff;\n"
                   "};\n"
                   "\n";
        }

        if (mOutputType == SH_HLSL_4_1_OUTPUT || mOutputType == SH_HLSL_4_0_FL9_3_OUTPUT)
        {
            out << "cbuffer DriverConstants : register(b1)\n"
                   "{\n";

            if (mUsesDepthRange)
            {
                out << "    float3 dx_DepthRange : packoffset(c0);\n";
            }

            // dx_ViewAdjust and dx_ViewCoords will only be used in Feature Level 9
            // shaders. However, we declare it for all shaders (including Feature Level 10+).
            // The bytecode is the same whether we declare it or not, since D3DCompiler removes it
            // if it's unused.
            out << "    float4 dx_ViewAdjust : packoffset(c1);\n";
            out << "    float2 dx_ViewCoords : packoffset(c2);\n";
            out << "    float2 dx_ViewScale  : packoffset(c3);\n";

            if (mHasMultiviewExtensionEnabled)
            {
                // We have to add a value which we can use to keep track of which multi-view code
                // path is to be selected in the GS.
                out << "    float multiviewSelectViewportIndex : packoffset(c3.z);\n";
            }

            if (mOutputType == SH_HLSL_4_1_OUTPUT)
            {
                mResourcesHLSL->samplerMetadataUniforms(out, "c4");
            }

            out << "};\n"
                   "\n";
        }
        else
        {
            if (mUsesDepthRange)
            {
                out << "uniform float3 dx_DepthRange : register(c0);\n";
            }

            out << "uniform float4 dx_ViewAdjust : register(c1);\n";
            out << "uniform float2 dx_ViewCoords : register(c2);\n"
                   "\n";
        }

        if (mUsesDepthRange)
        {
            out << "static gl_DepthRangeParameters gl_DepthRange = {dx_DepthRange.x, "
                   "dx_DepthRange.y, dx_DepthRange.z};\n"
                   "\n";
        }
    }
    else  // Compute shader
    {
        ASSERT(mShaderType == GL_COMPUTE_SHADER);

        out << "cbuffer DriverConstants : register(b1)\n"
               "{\n";
        if (mUsesNumWorkGroups)
        {
            out << "    uint3 gl_NumWorkGroups : packoffset(c0);\n";
        }
        ASSERT(mOutputType == SH_HLSL_4_1_OUTPUT);
        mResourcesHLSL->samplerMetadataUniforms(out, "c1");
        out << "};\n";

        std::ostringstream systemValueDeclaration;
        std::ostringstream glBuiltinInitialization;

        systemValueDeclaration << "\nstruct CS_INPUT\n{\n";
        glBuiltinInitialization << "\nvoid initGLBuiltins(CS_INPUT input)\n"
                                << "{\n";

        if (mUsesWorkGroupID)
        {
            out << "static uint3 gl_WorkGroupID = uint3(0, 0, 0);\n";
            systemValueDeclaration << "    uint3 dx_WorkGroupID : "
                                   << "SV_GroupID;\n";
            glBuiltinInitialization << "    gl_WorkGroupID = input.dx_WorkGroupID;\n";
        }

        if (mUsesLocalInvocationID)
        {
            out << "static uint3 gl_LocalInvocationID = uint3(0, 0, 0);\n";
            systemValueDeclaration << "    uint3 dx_LocalInvocationID : "
                                   << "SV_GroupThreadID;\n";
            glBuiltinInitialization << "    gl_LocalInvocationID = input.dx_LocalInvocationID;\n";
        }

        if (mUsesGlobalInvocationID)
        {
            out << "static uint3 gl_GlobalInvocationID = uint3(0, 0, 0);\n";
            systemValueDeclaration << "    uint3 dx_GlobalInvocationID : "
                                   << "SV_DispatchThreadID;\n";
            glBuiltinInitialization << "    gl_GlobalInvocationID = input.dx_GlobalInvocationID;\n";
        }

        if (mUsesLocalInvocationIndex)
        {
            out << "static uint gl_LocalInvocationIndex = uint(0);\n";
            systemValueDeclaration << "    uint dx_LocalInvocationIndex : "
                                   << "SV_GroupIndex;\n";
            glBuiltinInitialization
                << "    gl_LocalInvocationIndex = input.dx_LocalInvocationIndex;\n";
        }

        systemValueDeclaration << "};\n\n";
        glBuiltinInitialization << "};\n\n";

        out << systemValueDeclaration.str();
        out << glBuiltinInitialization.str();
    }

    if (!mappedStructs.empty())
    {
        out << "// Structures from std140 blocks with padding removed\n";
        out << "\n";
        out << mappedStructs;
        out << "\n";
    }

    bool getDimensionsIgnoresBaseLevel =
        (mCompileOptions & SH_HLSL_GET_DIMENSIONS_IGNORES_BASE_LEVEL) != 0;
    mTextureFunctionHLSL->textureFunctionHeader(out, mOutputType, getDimensionsIgnoresBaseLevel);
    mImageFunctionHLSL->imageFunctionHeader(out);
    mAtomicCounterFunctionHLSL->atomicCounterFunctionHeader(out);

    if (mUsesFragCoord)
    {
        out << "#define GL_USES_FRAG_COORD\n";
    }

    if (mUsesPointCoord)
    {
        out << "#define GL_USES_POINT_COORD\n";
    }

    if (mUsesFrontFacing)
    {
        out << "#define GL_USES_FRONT_FACING\n";
    }

    if (mUsesPointSize)
    {
        out << "#define GL_USES_POINT_SIZE\n";
    }

    if (mHasMultiviewExtensionEnabled)
    {
        out << "#define GL_ANGLE_MULTIVIEW_ENABLED\n";
    }

    if (mUsesViewID)
    {
        out << "#define GL_USES_VIEW_ID\n";
    }

    if (mUsesFragDepth)
    {
        out << "#define GL_USES_FRAG_DEPTH\n";
    }

    if (mUsesDepthRange)
    {
        out << "#define GL_USES_DEPTH_RANGE\n";
    }

    if (mUsesXor)
    {
        out << "bool xor(bool p, bool q)\n"
               "{\n"
               "    return (p || q) && !(p && q);\n"
               "}\n"
               "\n";
    }

    builtInFunctionEmulator->outputEmulatedFunctions(out);
}

void OutputHLSL::visitSymbol(TIntermSymbol *node)
{
    const TVariable &variable = node->variable();

    // Empty symbols can only appear in declarations and function arguments, and in either of those
    // cases the symbol nodes are not visited.
    ASSERT(variable.symbolType() != SymbolType::Empty);

    TInfoSinkBase &out = getInfoSink();

    // Handle accessing std140 structs by value
    if (IsInStd140UniformBlock(node) && node->getBasicType() == EbtStruct)
    {
        out << "map";
    }

    const ImmutableString &name     = variable.name();
    const TSymbolUniqueId &uniqueId = variable.uniqueId();

    if (name == "gl_DepthRange")
    {
        mUsesDepthRange = true;
        out << name;
    }
    else if (IsAtomicCounter(variable.getType().getBasicType()))
    {
        const TType &variableType = variable.getType();
        if (variableType.getQualifier() == EvqUniform)
        {
            TLayoutQualifier layout             = variableType.getLayoutQualifier();
            mReferencedUniforms[uniqueId.get()] = &variable;
            out << getAtomicCounterNameForBinding(layout.binding) << ", " << layout.offset;
        }
        else
        {
            TString varName = DecorateVariableIfNeeded(variable);
            out << varName << ", " << varName << "_offset";
        }
    }
    else
    {
        const TType &variableType = variable.getType();
        TQualifier qualifier      = variable.getType().getQualifier();

        ensureStructDefined(variableType);

        if (qualifier == EvqUniform)
        {
            const TInterfaceBlock *interfaceBlock = variableType.getInterfaceBlock();

            if (interfaceBlock)
            {
                if (mReferencedUniformBlocks.count(interfaceBlock->uniqueId().get()) == 0)
                {
                    const TVariable *instanceVariable = nullptr;
                    if (variableType.isInterfaceBlock())
                    {
                        instanceVariable = &variable;
                    }
                    mReferencedUniformBlocks[interfaceBlock->uniqueId().get()] =
                        new TReferencedBlock(interfaceBlock, instanceVariable);
                }
            }
            else
            {
                mReferencedUniforms[uniqueId.get()] = &variable;
            }

            out << DecorateVariableIfNeeded(variable);
        }
        else if (qualifier == EvqBuffer)
        {
            UNREACHABLE();
        }
        else if (qualifier == EvqAttribute || qualifier == EvqVertexIn)
        {
            mReferencedAttributes[uniqueId.get()] = &variable;
            out << Decorate(name);
        }
        else if (IsVarying(qualifier))
        {
            mReferencedVaryings[uniqueId.get()] = &variable;
            out << DecorateVariableIfNeeded(variable);
            if (variable.symbolType() == SymbolType::AngleInternal && name == "ViewID_OVR")
            {
                mUsesViewID = true;
            }
        }
        else if (qualifier == EvqFragmentOut)
        {
            mReferencedOutputVariables[uniqueId.get()] = &variable;
            out << "out_" << name;
        }
        else if (qualifier == EvqFragColor)
        {
            out << "gl_Color[0]";
            mUsesFragColor = true;
        }
        else if (qualifier == EvqFragData)
        {
            out << "gl_Color";
            mUsesFragData = true;
        }
        else if (qualifier == EvqFragCoord)
        {
            mUsesFragCoord = true;
            out << name;
        }
        else if (qualifier == EvqPointCoord)
        {
            mUsesPointCoord = true;
            out << name;
        }
        else if (qualifier == EvqFrontFacing)
        {
            mUsesFrontFacing = true;
            out << name;
        }
        else if (qualifier == EvqPointSize)
        {
            mUsesPointSize = true;
            out << name;
        }
        else if (qualifier == EvqInstanceID)
        {
            mUsesInstanceID = true;
            out << name;
        }
        else if (qualifier == EvqVertexID)
        {
            mUsesVertexID = true;
            out << name;
        }
        else if (name == "gl_FragDepthEXT" || name == "gl_FragDepth")
        {
            mUsesFragDepth = true;
            out << "gl_Depth";
        }
        else if (qualifier == EvqNumWorkGroups)
        {
            mUsesNumWorkGroups = true;
            out << name;
        }
        else if (qualifier == EvqWorkGroupID)
        {
            mUsesWorkGroupID = true;
            out << name;
        }
        else if (qualifier == EvqLocalInvocationID)
        {
            mUsesLocalInvocationID = true;
            out << name;
        }
        else if (qualifier == EvqGlobalInvocationID)
        {
            mUsesGlobalInvocationID = true;
            out << name;
        }
        else if (qualifier == EvqLocalInvocationIndex)
        {
            mUsesLocalInvocationIndex = true;
            out << name;
        }
        else
        {
            out << DecorateVariableIfNeeded(variable);
        }
    }
}

void OutputHLSL::outputEqual(Visit visit, const TType &type, TOperator op, TInfoSinkBase &out)
{
    if (type.isScalar() && !type.isArray())
    {
        if (op == EOpEqual)
        {
            outputTriplet(out, visit, "(", " == ", ")");
        }
        else
        {
            outputTriplet(out, visit, "(", " != ", ")");
        }
    }
    else
    {
        if (visit == PreVisit && op == EOpNotEqual)
        {
            out << "!";
        }

        if (type.isArray())
        {
            const TString &functionName = addArrayEqualityFunction(type);
            outputTriplet(out, visit, (functionName + "(").c_str(), ", ", ")");
        }
        else if (type.getBasicType() == EbtStruct)
        {
            const TStructure &structure = *type.getStruct();
            const TString &functionName = addStructEqualityFunction(structure);
            outputTriplet(out, visit, (functionName + "(").c_str(), ", ", ")");
        }
        else
        {
            ASSERT(type.isMatrix() || type.isVector());
            outputTriplet(out, visit, "all(", " == ", ")");
        }
    }
}

void OutputHLSL::outputAssign(Visit visit, const TType &type, TInfoSinkBase &out)
{
    if (type.isArray())
    {
        const TString &functionName = addArrayAssignmentFunction(type);
        outputTriplet(out, visit, (functionName + "(").c_str(), ", ", ")");
    }
    else
    {
        outputTriplet(out, visit, "(", " = ", ")");
    }
}

bool OutputHLSL::ancestorEvaluatesToSamplerInStruct()
{
    for (unsigned int n = 0u; getAncestorNode(n) != nullptr; ++n)
    {
        TIntermNode *ancestor               = getAncestorNode(n);
        const TIntermBinary *ancestorBinary = ancestor->getAsBinaryNode();
        if (ancestorBinary == nullptr)
        {
            return false;
        }
        switch (ancestorBinary->getOp())
        {
            case EOpIndexDirectStruct:
            {
                const TStructure *structure = ancestorBinary->getLeft()->getType().getStruct();
                const TIntermConstantUnion *index =
                    ancestorBinary->getRight()->getAsConstantUnion();
                const TField *field = structure->fields()[index->getIConst(0)];
                if (IsSampler(field->type()->getBasicType()))
                {
                    return true;
                }
                break;
            }
            case EOpIndexDirect:
                break;
            default:
                // Returning a sampler from indirect indexing is not supported.
                return false;
        }
    }
    return false;
}

bool OutputHLSL::visitSwizzle(Visit visit, TIntermSwizzle *node)
{
    TInfoSinkBase &out = getInfoSink();
    if (visit == PostVisit)
    {
        out << ".";
        node->writeOffsetsAsXYZW(&out);
    }
    return true;
}

bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
{
    TInfoSinkBase &out = getInfoSink();

    switch (node->getOp())
    {
        case EOpComma:
            outputTriplet(out, visit, "(", ", ", ")");
            break;
        case EOpAssign:
            if (node->isArray())
            {
                TIntermAggregate *rightAgg = node->getRight()->getAsAggregate();
                if (rightAgg != nullptr && rightAgg->isConstructor())
                {
                    const TString &functionName = addArrayConstructIntoFunction(node->getType());
                    out << functionName << "(";
                    node->getLeft()->traverse(this);
                    TIntermSequence *seq = rightAgg->getSequence();
                    for (auto &arrayElement : *seq)
                    {
                        out << ", ";
                        arrayElement->traverse(this);
                    }
                    out << ")";
                    return false;
                }
                // ArrayReturnValueToOutParameter should have eliminated expressions where a
                // function call is assigned.
                ASSERT(rightAgg == nullptr);
            }
            // Assignment expressions with atomic functions should be transformed into atomic
            // function calls in HLSL.
            // e.g. original_value = atomicAdd(dest, value) should be translated into
            //      InterlockedAdd(dest, value, original_value);
            else if (IsAtomicFunctionDirectAssign(*node))
            {
                TIntermAggregate *atomicFunctionNode = node->getRight()->getAsAggregate();
                TOperator atomicFunctionOp           = atomicFunctionNode->getOp();
                out << GetHLSLAtomicFunctionStringAndLeftParenthesis(atomicFunctionOp);
                TIntermSequence *argumentSeq = atomicFunctionNode->getSequence();
                ASSERT(argumentSeq->size() >= 2u);
                for (auto &argument : *argumentSeq)
                {
                    argument->traverse(this);
                    out << ", ";
                }
                node->getLeft()->traverse(this);
                out << ")";
                return false;
            }
            else if (IsInShaderStorageBlock(node->getLeft()))
            {
                mSSBOOutputHLSL->outputStoreFunctionCallPrefix(node->getLeft());
                out << ", ";
                if (IsInShaderStorageBlock(node->getRight()))
                {
                    mSSBOOutputHLSL->outputLoadFunctionCall(node->getRight());
                }
                else
                {
                    node->getRight()->traverse(this);
                }

                out << ")";
                return false;
            }
            else if (IsInShaderStorageBlock(node->getRight()))
            {
                node->getLeft()->traverse(this);
                out << " = ";
                mSSBOOutputHLSL->outputLoadFunctionCall(node->getRight());
                return false;
            }

            outputAssign(visit, node->getType(), out);
            break;
        case EOpInitialize:
            if (visit == PreVisit)
            {
                TIntermSymbol *symbolNode = node->getLeft()->getAsSymbolNode();
                ASSERT(symbolNode);
                TIntermTyped *initializer = node->getRight();

                // Global initializers must be constant at this point.
                ASSERT(symbolNode->getQualifier() != EvqGlobal || initializer->hasConstantValue());

                // GLSL allows to write things like "float x = x;" where a new variable x is defined
                // and the value of an existing variable x is assigned. HLSL uses C semantics (the
                // new variable is created before the assignment is evaluated), so we need to
                // convert
                // this to "float t = x, x = t;".
                if (writeSameSymbolInitializer(out, symbolNode, initializer))
                {
                    // Skip initializing the rest of the expression
                    return false;
                }
                else if (writeConstantInitialization(out, symbolNode, initializer))
                {
                    return false;
                }
            }
            else if (visit == InVisit)
            {
                out << " = ";
                if (IsInShaderStorageBlock(node->getRight()))
                {
                    mSSBOOutputHLSL->outputLoadFunctionCall(node->getRight());
                    return false;
                }
            }
            break;
        case EOpAddAssign:
            outputTriplet(out, visit, "(", " += ", ")");
            break;
        case EOpSubAssign:
            outputTriplet(out, visit, "(", " -= ", ")");
            break;
        case EOpMulAssign:
            outputTriplet(out, visit, "(", " *= ", ")");
            break;
        case EOpVectorTimesScalarAssign:
            outputTriplet(out, visit, "(", " *= ", ")");
            break;
        case EOpMatrixTimesScalarAssign:
            outputTriplet(out, visit, "(", " *= ", ")");
            break;
        case EOpVectorTimesMatrixAssign:
            if (visit == PreVisit)
            {
                out << "(";
            }
            else if (visit == InVisit)
            {
                out << " = mul(";
                node->getLeft()->traverse(this);
                out << ", transpose(";
            }
            else
            {
                out << ")))";
            }
            break;
        case EOpMatrixTimesMatrixAssign:
            if (visit == PreVisit)
            {
                out << "(";
            }
            else if (visit == InVisit)
            {
                out << " = transpose(mul(transpose(";
                node->getLeft()->traverse(this);
                out << "), transpose(";
            }
            else
            {
                out << "))))";
            }
            break;
        case EOpDivAssign:
            outputTriplet(out, visit, "(", " /= ", ")");
            break;
        case EOpIModAssign:
            outputTriplet(out, visit, "(", " %= ", ")");
            break;
        case EOpBitShiftLeftAssign:
            outputTriplet(out, visit, "(", " <<= ", ")");
            break;
        case EOpBitShiftRightAssign:
            outputTriplet(out, visit, "(", " >>= ", ")");
            break;
        case EOpBitwiseAndAssign:
            outputTriplet(out, visit, "(", " &= ", ")");
            break;
        case EOpBitwiseXorAssign:
            outputTriplet(out, visit, "(", " ^= ", ")");
            break;
        case EOpBitwiseOrAssign:
            outputTriplet(out, visit, "(", " |= ", ")");
            break;
        case EOpIndexDirect:
        {
            const TType &leftType = node->getLeft()->getType();
            if (leftType.isInterfaceBlock())
            {
                if (visit == PreVisit)
                {
                    TIntermSymbol *instanceArraySymbol    = node->getLeft()->getAsSymbolNode();
                    const TInterfaceBlock *interfaceBlock = leftType.getInterfaceBlock();

                    ASSERT(leftType.getQualifier() == EvqUniform);
                    if (mReferencedUniformBlocks.count(interfaceBlock->uniqueId().get()) == 0)
                    {
                        mReferencedUniformBlocks[interfaceBlock->uniqueId().get()] =
                            new TReferencedBlock(interfaceBlock, &instanceArraySymbol->variable());
                    }
                    const int arrayIndex = node->getRight()->getAsConstantUnion()->getIConst(0);
                    out << mResourcesHLSL->InterfaceBlockInstanceString(
                        instanceArraySymbol->getName(), arrayIndex);
                    return false;
                }
            }
            else if (ancestorEvaluatesToSamplerInStruct())
            {
                // All parts of an expression that access a sampler in a struct need to use _ as
                // separator to access the sampler variable that has been moved out of the struct.
                outputTriplet(out, visit, "", "_", "");
            }
            else if (IsAtomicCounter(leftType.getBasicType()))
            {
                outputTriplet(out, visit, "", " + (", ") * ATOMIC_COUNTER_ARRAY_STRIDE");
            }
            else
            {
                outputTriplet(out, visit, "", "[", "]");
            }
        }
        break;
        case EOpIndexIndirect:
        {
            // We do not currently support indirect references to interface blocks
            ASSERT(node->getLeft()->getBasicType() != EbtInterfaceBlock);

            const TType &leftType = node->getLeft()->getType();
            if (IsAtomicCounter(leftType.getBasicType()))
            {
                outputTriplet(out, visit, "", " + (", ") * ATOMIC_COUNTER_ARRAY_STRIDE");
            }
            else
            {
                outputTriplet(out, visit, "", "[", "]");
            }
            break;
        }
        case EOpIndexDirectStruct:
        {
            const TStructure *structure       = node->getLeft()->getType().getStruct();
            const TIntermConstantUnion *index = node->getRight()->getAsConstantUnion();
            const TField *field               = structure->fields()[index->getIConst(0)];

            // In cases where indexing returns a sampler, we need to access the sampler variable
            // that has been moved out of the struct.
            bool indexingReturnsSampler = IsSampler(field->type()->getBasicType());
            if (visit == PreVisit && indexingReturnsSampler)
            {
                // Samplers extracted from structs have "angle" prefix to avoid name conflicts.
                // This prefix is only output at the beginning of the indexing expression, which
                // may have multiple parts.
                out << "angle";
            }
            if (!indexingReturnsSampler)
            {
                // All parts of an expression that access a sampler in a struct need to use _ as
                // separator to access the sampler variable that has been moved out of the struct.
                indexingReturnsSampler = ancestorEvaluatesToSamplerInStruct();
            }
            if (visit == InVisit)
            {
                if (indexingReturnsSampler)
                {
                    out << "_" << field->name();
                }
                else
                {
                    out << "." << DecorateField(field->name(), *structure);
                }

                return false;
            }
        }
        break;
        case EOpIndexDirectInterfaceBlock:
        {
            ASSERT(!IsInShaderStorageBlock(node->getLeft()));
            bool structInStd140UniformBlock =
                node->getBasicType() == EbtStruct && IsInStd140UniformBlock(node->getLeft());
            if (visit == PreVisit && structInStd140UniformBlock)
            {
                out << "map";
            }
            if (visit == InVisit)
            {
                const TInterfaceBlock *interfaceBlock =
                    node->getLeft()->getType().getInterfaceBlock();
                const TIntermConstantUnion *index = node->getRight()->getAsConstantUnion();
                const TField *field               = interfaceBlock->fields()[index->getIConst(0)];
                if (structInStd140UniformBlock)
                {
                    out << "_";
                }
                else
                {
                    out << ".";
                }
                out << Decorate(field->name());

                return false;
            }
            break;
        }
        case EOpAdd:
            outputTriplet(out, visit, "(", " + ", ")");
            break;
        case EOpSub:
            outputTriplet(out, visit, "(", " - ", ")");
            break;
        case EOpMul:
            outputTriplet(out, visit, "(", " * ", ")");
            break;
        case EOpDiv:
            outputTriplet(out, visit, "(", " / ", ")");
            break;
        case EOpIMod:
            outputTriplet(out, visit, "(", " % ", ")");
            break;
        case EOpBitShiftLeft:
            outputTriplet(out, visit, "(", " << ", ")");
            break;
        case EOpBitShiftRight:
            outputTriplet(out, visit, "(", " >> ", ")");
            break;
        case EOpBitwiseAnd:
            outputTriplet(out, visit, "(", " & ", ")");
            break;
        case EOpBitwiseXor:
            outputTriplet(out, visit, "(", " ^ ", ")");
            break;
        case EOpBitwiseOr:
            outputTriplet(out, visit, "(", " | ", ")");
            break;
        case EOpEqual:
        case EOpNotEqual:
            outputEqual(visit, node->getLeft()->getType(), node->getOp(), out);
            break;
        case EOpLessThan:
            outputTriplet(out, visit, "(", " < ", ")");
            break;
        case EOpGreaterThan:
            outputTriplet(out, visit, "(", " > ", ")");
            break;
        case EOpLessThanEqual:
            outputTriplet(out, visit, "(", " <= ", ")");
            break;
        case EOpGreaterThanEqual:
            outputTriplet(out, visit, "(", " >= ", ")");
            break;
        case EOpVectorTimesScalar:
            outputTriplet(out, visit, "(", " * ", ")");
            break;
        case EOpMatrixTimesScalar:
            outputTriplet(out, visit, "(", " * ", ")");
            break;
        case EOpVectorTimesMatrix:
            outputTriplet(out, visit, "mul(", ", transpose(", "))");
            break;
        case EOpMatrixTimesVector:
            outputTriplet(out, visit, "mul(transpose(", "), ", ")");
            break;
        case EOpMatrixTimesMatrix:
            outputTriplet(out, visit, "transpose(mul(transpose(", "), transpose(", ")))");
            break;
        case EOpLogicalOr:
            // HLSL doesn't short-circuit ||, so we assume that || affected by short-circuiting have
            // been unfolded.
            ASSERT(!node->getRight()->hasSideEffects());
            outputTriplet(out, visit, "(", " || ", ")");
            return true;
        case EOpLogicalXor:
            mUsesXor = true;
            outputTriplet(out, visit, "xor(", ", ", ")");
            break;
        case EOpLogicalAnd:
            // HLSL doesn't short-circuit &&, so we assume that && affected by short-circuiting have
            // been unfolded.
            ASSERT(!node->getRight()->hasSideEffects());
            outputTriplet(out, visit, "(", " && ", ")");
            return true;
        default:
            UNREACHABLE();
    }

    return true;
}

bool OutputHLSL::visitUnary(Visit visit, TIntermUnary *node)
{
    TInfoSinkBase &out = getInfoSink();

    switch (node->getOp())
    {
        case EOpNegative:
            outputTriplet(out, visit, "(-", "", ")");
            break;
        case EOpPositive:
            outputTriplet(out, visit, "(+", "", ")");
            break;
        case EOpLogicalNot:
            outputTriplet(out, visit, "(!", "", ")");
            break;
        case EOpBitwiseNot:
            outputTriplet(out, visit, "(~", "", ")");
            break;
        case EOpPostIncrement:
            outputTriplet(out, visit, "(", "", "++)");
            break;
        case EOpPostDecrement:
            outputTriplet(out, visit, "(", "", "--)");
            break;
        case EOpPreIncrement:
            outputTriplet(out, visit, "(++", "", ")");
            break;
        case EOpPreDecrement:
            outputTriplet(out, visit, "(--", "", ")");
            break;
        case EOpRadians:
            outputTriplet(out, visit, "radians(", "", ")");
            break;
        case EOpDegrees:
            outputTriplet(out, visit, "degrees(", "", ")");
            break;
        case EOpSin:
            outputTriplet(out, visit, "sin(", "", ")");
            break;
        case EOpCos:
            outputTriplet(out, visit, "cos(", "", ")");
            break;
        case EOpTan:
            outputTriplet(out, visit, "tan(", "", ")");
            break;
        case EOpAsin:
            outputTriplet(out, visit, "asin(", "", ")");
            break;
        case EOpAcos:
            outputTriplet(out, visit, "acos(", "", ")");
            break;
        case EOpAtan:
            outputTriplet(out, visit, "atan(", "", ")");
            break;
        case EOpSinh:
            outputTriplet(out, visit, "sinh(", "", ")");
            break;
        case EOpCosh:
            outputTriplet(out, visit, "cosh(", "", ")");
            break;
        case EOpTanh:
        case EOpAsinh:
        case EOpAcosh:
        case EOpAtanh:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpExp:
            outputTriplet(out, visit, "exp(", "", ")");
            break;
        case EOpLog:
            outputTriplet(out, visit, "log(", "", ")");
            break;
        case EOpExp2:
            outputTriplet(out, visit, "exp2(", "", ")");
            break;
        case EOpLog2:
            outputTriplet(out, visit, "log2(", "", ")");
            break;
        case EOpSqrt:
            outputTriplet(out, visit, "sqrt(", "", ")");
            break;
        case EOpInversesqrt:
            outputTriplet(out, visit, "rsqrt(", "", ")");
            break;
        case EOpAbs:
            outputTriplet(out, visit, "abs(", "", ")");
            break;
        case EOpSign:
            outputTriplet(out, visit, "sign(", "", ")");
            break;
        case EOpFloor:
            outputTriplet(out, visit, "floor(", "", ")");
            break;
        case EOpTrunc:
            outputTriplet(out, visit, "trunc(", "", ")");
            break;
        case EOpRound:
            outputTriplet(out, visit, "round(", "", ")");
            break;
        case EOpRoundEven:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpCeil:
            outputTriplet(out, visit, "ceil(", "", ")");
            break;
        case EOpFract:
            outputTriplet(out, visit, "frac(", "", ")");
            break;
        case EOpIsnan:
            if (node->getUseEmulatedFunction())
                writeEmulatedFunctionTriplet(out, visit, node->getOp());
            else
                outputTriplet(out, visit, "isnan(", "", ")");
            mRequiresIEEEStrictCompiling = true;
            break;
        case EOpIsinf:
            outputTriplet(out, visit, "isinf(", "", ")");
            break;
        case EOpFloatBitsToInt:
            outputTriplet(out, visit, "asint(", "", ")");
            break;
        case EOpFloatBitsToUint:
            outputTriplet(out, visit, "asuint(", "", ")");
            break;
        case EOpIntBitsToFloat:
            outputTriplet(out, visit, "asfloat(", "", ")");
            break;
        case EOpUintBitsToFloat:
            outputTriplet(out, visit, "asfloat(", "", ")");
            break;
        case EOpPackSnorm2x16:
        case EOpPackUnorm2x16:
        case EOpPackHalf2x16:
        case EOpUnpackSnorm2x16:
        case EOpUnpackUnorm2x16:
        case EOpUnpackHalf2x16:
        case EOpPackUnorm4x8:
        case EOpPackSnorm4x8:
        case EOpUnpackUnorm4x8:
        case EOpUnpackSnorm4x8:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpLength:
            outputTriplet(out, visit, "length(", "", ")");
            break;
        case EOpNormalize:
            outputTriplet(out, visit, "normalize(", "", ")");
            break;
        case EOpDFdx:
            if (mInsideDiscontinuousLoop || mOutputLod0Function)
            {
                outputTriplet(out, visit, "(", "", ", 0.0)");
            }
            else
            {
                outputTriplet(out, visit, "ddx(", "", ")");
            }
            break;
        case EOpDFdy:
            if (mInsideDiscontinuousLoop || mOutputLod0Function)
            {
                outputTriplet(out, visit, "(", "", ", 0.0)");
            }
            else
            {
                outputTriplet(out, visit, "ddy(", "", ")");
            }
            break;
        case EOpFwidth:
            if (mInsideDiscontinuousLoop || mOutputLod0Function)
            {
                outputTriplet(out, visit, "(", "", ", 0.0)");
            }
            else
            {
                outputTriplet(out, visit, "fwidth(", "", ")");
            }
            break;
        case EOpTranspose:
            outputTriplet(out, visit, "transpose(", "", ")");
            break;
        case EOpDeterminant:
            outputTriplet(out, visit, "determinant(transpose(", "", "))");
            break;
        case EOpInverse:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;

        case EOpAny:
            outputTriplet(out, visit, "any(", "", ")");
            break;
        case EOpAll:
            outputTriplet(out, visit, "all(", "", ")");
            break;
        case EOpLogicalNotComponentWise:
            outputTriplet(out, visit, "(!", "", ")");
            break;
        case EOpBitfieldReverse:
            outputTriplet(out, visit, "reversebits(", "", ")");
            break;
        case EOpBitCount:
            outputTriplet(out, visit, "countbits(", "", ")");
            break;
        case EOpFindLSB:
            // Note that it's unclear from the HLSL docs what this returns for 0, but this is tested
            // in GLSLTest and results are consistent with GL.
            outputTriplet(out, visit, "firstbitlow(", "", ")");
            break;
        case EOpFindMSB:
            // Note that it's unclear from the HLSL docs what this returns for 0 or -1, but this is
            // tested in GLSLTest and results are consistent with GL.
            outputTriplet(out, visit, "firstbithigh(", "", ")");
            break;
        default:
            UNREACHABLE();
    }

    return true;
}

ImmutableString OutputHLSL::samplerNamePrefixFromStruct(TIntermTyped *node)
{
    if (node->getAsSymbolNode())
    {
        ASSERT(node->getAsSymbolNode()->variable().symbolType() != SymbolType::Empty);
        return node->getAsSymbolNode()->getName();
    }
    TIntermBinary *nodeBinary = node->getAsBinaryNode();
    switch (nodeBinary->getOp())
    {
        case EOpIndexDirect:
        {
            int index = nodeBinary->getRight()->getAsConstantUnion()->getIConst(0);

            std::stringstream prefixSink;
            prefixSink << samplerNamePrefixFromStruct(nodeBinary->getLeft()) << "_" << index;
            return ImmutableString(prefixSink.str());
        }
        case EOpIndexDirectStruct:
        {
            const TStructure *s = nodeBinary->getLeft()->getAsTyped()->getType().getStruct();
            int index           = nodeBinary->getRight()->getAsConstantUnion()->getIConst(0);
            const TField *field = s->fields()[index];

            std::stringstream prefixSink;
            prefixSink << samplerNamePrefixFromStruct(nodeBinary->getLeft()) << "_"
                       << field->name();
            return ImmutableString(prefixSink.str());
        }
        default:
            UNREACHABLE();
            return kEmptyImmutableString;
    }
}

bool OutputHLSL::visitBlock(Visit visit, TIntermBlock *node)
{
    TInfoSinkBase &out = getInfoSink();

    bool isMainBlock = mInsideMain && getParentNode()->getAsFunctionDefinition();

    if (mInsideFunction)
    {
        outputLineDirective(out, node->getLine().first_line);
        out << "{\n";
        if (isMainBlock)
        {
            if (mShaderType == GL_COMPUTE_SHADER)
            {
                out << "initGLBuiltins(input);\n";
            }
            else
            {
                out << "@@ MAIN PROLOGUE @@\n";
            }
        }
    }

    for (TIntermNode *statement : *node->getSequence())
    {
        outputLineDirective(out, statement->getLine().first_line);

        statement->traverse(this);

        // Don't output ; after case labels, they're terminated by :
        // This is needed especially since outputting a ; after a case statement would turn empty
        // case statements into non-empty case statements, disallowing fall-through from them.
        // Also the output code is clearer if we don't output ; after statements where it is not
        // needed:
        //  * if statements
        //  * switch statements
        //  * blocks
        //  * function definitions
        //  * loops (do-while loops output the semicolon in VisitLoop)
        //  * declarations that don't generate output.
        if (statement->getAsCaseNode() == nullptr && statement->getAsIfElseNode() == nullptr &&
            statement->getAsBlock() == nullptr && statement->getAsLoopNode() == nullptr &&
            statement->getAsSwitchNode() == nullptr &&
            statement->getAsFunctionDefinition() == nullptr &&
            (statement->getAsDeclarationNode() == nullptr ||
             IsDeclarationWrittenOut(statement->getAsDeclarationNode())) &&
            statement->getAsInvariantDeclarationNode() == nullptr)
        {
            out << ";\n";
        }
    }

    if (mInsideFunction)
    {
        outputLineDirective(out, node->getLine().last_line);
        if (isMainBlock && shaderNeedsGenerateOutput())
        {
            // We could have an empty main, a main function without a branch at the end, or a main
            // function with a discard statement at the end. In these cases we need to add a return
            // statement.
            bool needReturnStatement =
                node->getSequence()->empty() || !node->getSequence()->back()->getAsBranchNode() ||
                node->getSequence()->back()->getAsBranchNode()->getFlowOp() != EOpReturn;
            if (needReturnStatement)
            {
                out << "return " << generateOutputCall() << ";\n";
            }
        }
        out << "}\n";
    }

    return false;
}

bool OutputHLSL::visitFunctionDefinition(Visit visit, TIntermFunctionDefinition *node)
{
    TInfoSinkBase &out = getInfoSink();

    ASSERT(mCurrentFunctionMetadata == nullptr);

    size_t index = mCallDag.findIndex(node->getFunction()->uniqueId());
    ASSERT(index != CallDAG::InvalidIndex);
    mCurrentFunctionMetadata = &mASTMetadataList[index];

    const TFunction *func = node->getFunction();

    if (func->isMain())
    {
        // The stub strings below are replaced when shader is dynamically defined by its layout:
        switch (mShaderType)
        {
            case GL_VERTEX_SHADER:
                out << "@@ VERTEX ATTRIBUTES @@\n\n"
                    << "@@ VERTEX OUTPUT @@\n\n"
                    << "VS_OUTPUT main(VS_INPUT input)";
                break;
            case GL_FRAGMENT_SHADER:
                out << "@@ PIXEL OUTPUT @@\n\n"
                    << "PS_OUTPUT main(@@ PIXEL MAIN PARAMETERS @@)";
                break;
            case GL_COMPUTE_SHADER:
                out << "[numthreads(" << mWorkGroupSize[0] << ", " << mWorkGroupSize[1] << ", "
                    << mWorkGroupSize[2] << ")]\n";
                out << "void main(CS_INPUT input)";
                break;
            default:
                UNREACHABLE();
                break;
        }
    }
    else
    {
        out << TypeString(node->getFunctionPrototype()->getType()) << " ";
        out << DecorateFunctionIfNeeded(func) << DisambiguateFunctionName(func)
            << (mOutputLod0Function ? "Lod0(" : "(");

        size_t paramCount = func->getParamCount();
        for (unsigned int i = 0; i < paramCount; i++)
        {
            const TVariable *param = func->getParam(i);
            ensureStructDefined(param->getType());

            writeParameter(param, out);

            if (i < paramCount - 1)
            {
                out << ", ";
            }
        }

        out << ")\n";
    }

    mInsideFunction = true;
    if (func->isMain())
    {
        mInsideMain = true;
    }
    // The function body node will output braces.
    node->getBody()->traverse(this);
    mInsideFunction = false;
    mInsideMain     = false;

    mCurrentFunctionMetadata = nullptr;

    bool needsLod0 = mASTMetadataList[index].mNeedsLod0;
    if (needsLod0 && !mOutputLod0Function && mShaderType == GL_FRAGMENT_SHADER)
    {
        ASSERT(!node->getFunction()->isMain());
        mOutputLod0Function = true;
        node->traverse(this);
        mOutputLod0Function = false;
    }

    return false;
}

bool OutputHLSL::visitDeclaration(Visit visit, TIntermDeclaration *node)
{
    if (visit == PreVisit)
    {
        TIntermSequence *sequence = node->getSequence();
        TIntermTyped *declarator  = (*sequence)[0]->getAsTyped();
        ASSERT(sequence->size() == 1);
        ASSERT(declarator);

        if (IsDeclarationWrittenOut(node))
        {
            TInfoSinkBase &out = getInfoSink();
            ensureStructDefined(declarator->getType());

            if (!declarator->getAsSymbolNode() ||
                declarator->getAsSymbolNode()->variable().symbolType() !=
                    SymbolType::Empty)  // Variable declaration
            {
                if (declarator->getQualifier() == EvqShared)
                {
                    out << "groupshared ";
                }
                else if (!mInsideFunction)
                {
                    out << "static ";
                }

                out << TypeString(declarator->getType()) + " ";

                TIntermSymbol *symbol = declarator->getAsSymbolNode();

                if (symbol)
                {
                    symbol->traverse(this);
                    out << ArrayString(symbol->getType());
                    if (declarator->getQualifier() != EvqShared ||
                        mCompileOptions & SH_INIT_SHARED_VARIABLES)
                    {
                        out << " = " + zeroInitializer(symbol->getType());
                    }
                }
                else
                {
                    declarator->traverse(this);
                }
            }
        }
        else if (IsVaryingOut(declarator->getQualifier()))
        {
            TIntermSymbol *symbol = declarator->getAsSymbolNode();
            ASSERT(symbol);  // Varying declarations can't have initializers.

            const TVariable &variable = symbol->variable();

            if (variable.symbolType() != SymbolType::Empty)
            {
                // Vertex outputs which are declared but not written to should still be declared to
                // allow successful linking.
                mReferencedVaryings[symbol->uniqueId().get()] = &variable;
            }
        }
    }
    return false;
}

bool OutputHLSL::visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node)
{
    // Do not do any translation
    return false;
}

void OutputHLSL::visitFunctionPrototype(TIntermFunctionPrototype *node)
{
    TInfoSinkBase &out = getInfoSink();

    size_t index = mCallDag.findIndex(node->getFunction()->uniqueId());
    // Skip the prototype if it is not implemented (and thus not used)
    if (index == CallDAG::InvalidIndex)
    {
        return;
    }

    const TFunction *func = node->getFunction();

    TString name = DecorateFunctionIfNeeded(func);
    out << TypeString(node->getType()) << " " << name << DisambiguateFunctionName(func)
        << (mOutputLod0Function ? "Lod0(" : "(");

    size_t paramCount = func->getParamCount();
    for (unsigned int i = 0; i < paramCount; i++)
    {
        writeParameter(func->getParam(i), out);

        if (i < paramCount - 1)
        {
            out << ", ";
        }
    }

    out << ");\n";

    // Also prototype the Lod0 variant if needed
    bool needsLod0 = mASTMetadataList[index].mNeedsLod0;
    if (needsLod0 && !mOutputLod0Function && mShaderType == GL_FRAGMENT_SHADER)
    {
        mOutputLod0Function = true;
        node->traverse(this);
        mOutputLod0Function = false;
    }
}

bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
{
    TInfoSinkBase &out = getInfoSink();

    switch (node->getOp())
    {
        case EOpCallBuiltInFunction:
        case EOpCallFunctionInAST:
        case EOpCallInternalRawFunction:
        {
            TIntermSequence *arguments = node->getSequence();

            bool lod0 = mInsideDiscontinuousLoop || mOutputLod0Function;
            if (node->getOp() == EOpCallFunctionInAST)
            {
                if (node->isArray())
                {
                    UNIMPLEMENTED();
                }
                size_t index = mCallDag.findIndex(node->getFunction()->uniqueId());
                ASSERT(index != CallDAG::InvalidIndex);
                lod0 &= mASTMetadataList[index].mNeedsLod0;

                out << DecorateFunctionIfNeeded(node->getFunction());
                out << DisambiguateFunctionName(node->getSequence());
                out << (lod0 ? "Lod0(" : "(");
            }
            else if (node->getOp() == EOpCallInternalRawFunction)
            {
                // This path is used for internal functions that don't have their definitions in the
                // AST, such as precision emulation functions.
                out << DecorateFunctionIfNeeded(node->getFunction()) << "(";
            }
            else if (node->getFunction()->isImageFunction())
            {
                const ImmutableString &name              = node->getFunction()->name();
                TType type                               = (*arguments)[0]->getAsTyped()->getType();
                const ImmutableString &imageFunctionName = mImageFunctionHLSL->useImageFunction(
                    name, type.getBasicType(), type.getLayoutQualifier().imageInternalFormat,
                    type.getMemoryQualifier().readonly);
                out << imageFunctionName << "(";
            }
            else if (node->getFunction()->isAtomicCounterFunction())
            {
                const ImmutableString &name = node->getFunction()->name();
                ImmutableString atomicFunctionName =
                    mAtomicCounterFunctionHLSL->useAtomicCounterFunction(name);
                out << atomicFunctionName << "(";
            }
            else
            {
                const ImmutableString &name = node->getFunction()->name();
                TBasicType samplerType = (*arguments)[0]->getAsTyped()->getType().getBasicType();
                int coords = 0;  // textureSize(gsampler2DMS) doesn't have a second argument.
                if (arguments->size() > 1)
                {
                    coords = (*arguments)[1]->getAsTyped()->getNominalSize();
                }
                const ImmutableString &textureFunctionName =
                    mTextureFunctionHLSL->useTextureFunction(name, samplerType, coords,
                                                             arguments->size(), lod0, mShaderType);
                out << textureFunctionName << "(";
            }

            for (TIntermSequence::iterator arg = arguments->begin(); arg != arguments->end(); arg++)
            {
                TIntermTyped *typedArg = (*arg)->getAsTyped();
                if (mOutputType == SH_HLSL_4_0_FL9_3_OUTPUT && IsSampler(typedArg->getBasicType()))
                {
                    out << "texture_";
                    (*arg)->traverse(this);
                    out << ", sampler_";
                }

                (*arg)->traverse(this);

                if (typedArg->getType().isStructureContainingSamplers())
                {
                    const TType &argType = typedArg->getType();
                    TVector<const TVariable *> samplerSymbols;
                    ImmutableString structName = samplerNamePrefixFromStruct(typedArg);
                    std::string namePrefix     = "angle_";
                    namePrefix += structName.data();
                    argType.createSamplerSymbols(ImmutableString(namePrefix), "", &samplerSymbols,
                                                 nullptr, mSymbolTable);
                    for (const TVariable *sampler : samplerSymbols)
                    {
                        if (mOutputType == SH_HLSL_4_0_FL9_3_OUTPUT)
                        {
                            out << ", texture_" << sampler->name();
                            out << ", sampler_" << sampler->name();
                        }
                        else
                        {
                            // In case of HLSL 4.1+, this symbol is the sampler index, and in case
                            // of D3D9, it's the sampler variable.
                            out << ", " << sampler->name();
                        }
                    }
                }

                if (arg < arguments->end() - 1)
                {
                    out << ", ";
                }
            }

            out << ")";

            return false;
        }
        case EOpConstruct:
            outputConstructor(out, visit, node);
            break;
        case EOpEqualComponentWise:
            outputTriplet(out, visit, "(", " == ", ")");
            break;
        case EOpNotEqualComponentWise:
            outputTriplet(out, visit, "(", " != ", ")");
            break;
        case EOpLessThanComponentWise:
            outputTriplet(out, visit, "(", " < ", ")");
            break;
        case EOpGreaterThanComponentWise:
            outputTriplet(out, visit, "(", " > ", ")");
            break;
        case EOpLessThanEqualComponentWise:
            outputTriplet(out, visit, "(", " <= ", ")");
            break;
        case EOpGreaterThanEqualComponentWise:
            outputTriplet(out, visit, "(", " >= ", ")");
            break;
        case EOpMod:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpModf:
            outputTriplet(out, visit, "modf(", ", ", ")");
            break;
        case EOpPow:
            outputTriplet(out, visit, "pow(", ", ", ")");
            break;
        case EOpAtan:
            ASSERT(node->getSequence()->size() == 2);  // atan(x) is a unary operator
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpMin:
            outputTriplet(out, visit, "min(", ", ", ")");
            break;
        case EOpMax:
            outputTriplet(out, visit, "max(", ", ", ")");
            break;
        case EOpClamp:
            outputTriplet(out, visit, "clamp(", ", ", ")");
            break;
        case EOpMix:
        {
            TIntermTyped *lastParamNode = (*(node->getSequence()))[2]->getAsTyped();
            if (lastParamNode->getType().getBasicType() == EbtBool)
            {
                // There is no HLSL equivalent for ESSL3 built-in "genType mix (genType x, genType
                // y, genBType a)",
                // so use emulated version.
                ASSERT(node->getUseEmulatedFunction());
                writeEmulatedFunctionTriplet(out, visit, node->getOp());
            }
            else
            {
                outputTriplet(out, visit, "lerp(", ", ", ")");
            }
            break;
        }
        case EOpStep:
            outputTriplet(out, visit, "step(", ", ", ")");
            break;
        case EOpSmoothstep:
            outputTriplet(out, visit, "smoothstep(", ", ", ")");
            break;
        case EOpFrexp:
        case EOpLdexp:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpDistance:
            outputTriplet(out, visit, "distance(", ", ", ")");
            break;
        case EOpDot:
            outputTriplet(out, visit, "dot(", ", ", ")");
            break;
        case EOpCross:
            outputTriplet(out, visit, "cross(", ", ", ")");
            break;
        case EOpFaceforward:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpReflect:
            outputTriplet(out, visit, "reflect(", ", ", ")");
            break;
        case EOpRefract:
            outputTriplet(out, visit, "refract(", ", ", ")");
            break;
        case EOpOuterProduct:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpMulMatrixComponentWise:
            outputTriplet(out, visit, "(", " * ", ")");
            break;
        case EOpBitfieldExtract:
        case EOpBitfieldInsert:
        case EOpUaddCarry:
        case EOpUsubBorrow:
        case EOpUmulExtended:
        case EOpImulExtended:
            ASSERT(node->getUseEmulatedFunction());
            writeEmulatedFunctionTriplet(out, visit, node->getOp());
            break;
        case EOpBarrier:
            // barrier() is translated to GroupMemoryBarrierWithGroupSync(), which is the
            // cheapest *WithGroupSync() function, without any functionality loss, but
            // with the potential for severe performance loss.
            outputTriplet(out, visit, "GroupMemoryBarrierWithGroupSync(", "", ")");
            break;
        case EOpMemoryBarrierShared:
            outputTriplet(out, visit, "GroupMemoryBarrier(", "", ")");
            break;
        case EOpMemoryBarrierAtomicCounter:
        case EOpMemoryBarrierBuffer:
        case EOpMemoryBarrierImage:
            outputTriplet(out, visit, "DeviceMemoryBarrier(", "", ")");
            break;
        case EOpGroupMemoryBarrier:
        case EOpMemoryBarrier:
            outputTriplet(out, visit, "AllMemoryBarrier(", "", ")");
            break;

        // Single atomic function calls without return value.
        // e.g. atomicAdd(dest, value) should be translated into InterlockedAdd(dest, value).
        case EOpAtomicAdd:
        case EOpAtomicMin:
        case EOpAtomicMax:
        case EOpAtomicAnd:
        case EOpAtomicOr:
        case EOpAtomicXor:
            outputTriplet(out, visit, GetHLSLAtomicFunctionStringAndLeftParenthesis(node->getOp()),
                          ",", ")");
            break;

        // The parameter 'original_value' of InterlockedExchange(dest, value, original_value) and
        // InterlockedCompareExchange(dest, compare_value, value, original_value) is not optional.
        // https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/interlockedexchange
        // https://docs.microsoft.com/en-us/windows/desktop/direct3dhlsl/interlockedcompareexchange
        // So all the call of atomicExchange(dest, value) and atomicCompSwap(dest, compare_value,
        // value) should all be modified into the form of "int temp; temp = atomicExchange(dest,
        // value);" and "int temp; temp = atomicCompSwap(dest, compare_value, value);" in the
        // intermediate tree before traversing outputHLSL.
        case EOpAtomicExchange:
        case EOpAtomicCompSwap:
        default:
            UNREACHABLE();
    }

    return true;
}

void OutputHLSL::writeIfElse(TInfoSinkBase &out, TIntermIfElse *node)
{
    out << "if (";

    node->getCondition()->traverse(this);

    out << ")\n";

    outputLineDirective(out, node->getLine().first_line);

    bool discard = false;

    if (node->getTrueBlock())
    {
        // The trueBlock child node will output braces.
        node->getTrueBlock()->traverse(this);

        // Detect true discard
        discard = (discard || FindDiscard::search(node->getTrueBlock()));
    }
    else
    {
        // TODO(oetuaho): Check if the semicolon inside is necessary.
        // It's there as a result of conservative refactoring of the output.
        out << "{;}\n";
    }

    outputLineDirective(out, node->getLine().first_line);

    if (node->getFalseBlock())
    {
        out << "else\n";

        outputLineDirective(out, node->getFalseBlock()->getLine().first_line);

        // The falseBlock child node will output braces.
        node->getFalseBlock()->traverse(this);

        outputLineDirective(out, node->getFalseBlock()->getLine().first_line);

        // Detect false discard
        discard = (discard || FindDiscard::search(node->getFalseBlock()));
    }

    // ANGLE issue 486: Detect problematic conditional discard
    if (discard)
    {
        mUsesDiscardRewriting = true;
    }
}

bool OutputHLSL::visitTernary(Visit, TIntermTernary *)
{
    // Ternary ops should have been already converted to something else in the AST. HLSL ternary
    // operator doesn't short-circuit, so it's not the same as the GLSL ternary operator.
    UNREACHABLE();
    return false;
}

bool OutputHLSL::visitIfElse(Visit visit, TIntermIfElse *node)
{
    TInfoSinkBase &out = getInfoSink();

    ASSERT(mInsideFunction);

    // D3D errors when there is a gradient operation in a loop in an unflattened if.
    if (mShaderType == GL_FRAGMENT_SHADER && mCurrentFunctionMetadata->hasGradientLoop(node))
    {
        out << "FLATTEN ";
    }

    writeIfElse(out, node);

    return false;
}

bool OutputHLSL::visitSwitch(Visit visit, TIntermSwitch *node)
{
    TInfoSinkBase &out = getInfoSink();

    ASSERT(node->getStatementList());
    if (visit == PreVisit)
    {
        node->setStatementList(RemoveSwitchFallThrough(node->getStatementList(), mPerfDiagnostics));
    }
    outputTriplet(out, visit, "switch (", ") ", "");
    // The curly braces get written when visiting the statementList block.
    return true;
}

bool OutputHLSL::visitCase(Visit visit, TIntermCase *node)
{
    TInfoSinkBase &out = getInfoSink();

    if (node->hasCondition())
    {
        outputTriplet(out, visit, "case (", "", "):\n");
        return true;
    }
    else
    {
        out << "default:\n";
        return false;
    }
}

void OutputHLSL::visitConstantUnion(TIntermConstantUnion *node)
{
    TInfoSinkBase &out = getInfoSink();
    writeConstantUnion(out, node->getType(), node->getConstantValue());
}

bool OutputHLSL::visitLoop(Visit visit, TIntermLoop *node)
{
    mNestedLoopDepth++;

    bool wasDiscontinuous = mInsideDiscontinuousLoop;
    mInsideDiscontinuousLoop =
        mInsideDiscontinuousLoop || mCurrentFunctionMetadata->mDiscontinuousLoops.count(node) > 0;

    TInfoSinkBase &out = getInfoSink();

    if (mOutputType == SH_HLSL_3_0_OUTPUT)
    {
        if (handleExcessiveLoop(out, node))
        {
            mInsideDiscontinuousLoop = wasDiscontinuous;
            mNestedLoopDepth--;

            return false;
        }
    }

    const char *unroll = mCurrentFunctionMetadata->hasGradientInCallGraph(node) ? "LOOP" : "";
    if (node->getType() == ELoopDoWhile)
    {
        out << "{" << unroll << " do\n";

        outputLineDirective(out, node->getLine().first_line);
    }
    else
    {
        out << "{" << unroll << " for(";

        if (node->getInit())
        {
            node->getInit()->traverse(this);
        }

        out << "; ";

        if (node->getCondition())
        {
            node->getCondition()->traverse(this);
        }

        out << "; ";

        if (node->getExpression())
        {
            node->getExpression()->traverse(this);
        }

        out << ")\n";

        outputLineDirective(out, node->getLine().first_line);
    }

    if (node->getBody())
    {
        // The loop body node will output braces.
        node->getBody()->traverse(this);
    }
    else
    {
        // TODO(oetuaho): Check if the semicolon inside is necessary.
        // It's there as a result of conservative refactoring of the output.
        out << "{;}\n";
    }

    outputLineDirective(out, node->getLine().first_line);

    if (node->getType() == ELoopDoWhile)
    {
        outputLineDirective(out, node->getCondition()->getLine().first_line);
        out << "while (";

        node->getCondition()->traverse(this);

        out << ");\n";
    }

    out << "}\n";

    mInsideDiscontinuousLoop = wasDiscontinuous;
    mNestedLoopDepth--;

    return false;
}

bool OutputHLSL::visitBranch(Visit visit, TIntermBranch *node)
{
    if (visit == PreVisit)
    {
        TInfoSinkBase &out = getInfoSink();

        switch (node->getFlowOp())
        {
            case EOpKill:
                out << "discard";
                break;
            case EOpBreak:
                if (mNestedLoopDepth > 1)
                {
                    mUsesNestedBreak = true;
                }

                if (mExcessiveLoopIndex)
                {
                    out << "{Break";
                    mExcessiveLoopIndex->traverse(this);
                    out << " = true; break;}\n";
                }
                else
                {
                    out << "break";
                }
                break;
            case EOpContinue:
                out << "continue";
                break;
            case EOpReturn:
                if (node->getExpression())
                {
                    ASSERT(!mInsideMain);
                    out << "return ";
                }
                else
                {
                    if (mInsideMain && shaderNeedsGenerateOutput())
                    {
                        out << "return " << generateOutputCall();
                    }
                    else
                    {
                        out << "return";
                    }
                }
                break;
            default:
                UNREACHABLE();
        }
    }

    return true;
}

// Handle loops with more than 254 iterations (unsupported by D3D9) by splitting them
// (The D3D documentation says 255 iterations, but the compiler complains at anything more than
// 254).
bool OutputHLSL::handleExcessiveLoop(TInfoSinkBase &out, TIntermLoop *node)
{
    const int MAX_LOOP_ITERATIONS = 254;

    // Parse loops of the form:
    // for(int index = initial; index [comparator] limit; index += increment)
    TIntermSymbol *index = nullptr;
    TOperator comparator = EOpNull;
    int initial          = 0;
    int limit            = 0;
    int increment        = 0;

    // Parse index name and intial value
    if (node->getInit())
    {
        TIntermDeclaration *init = node->getInit()->getAsDeclarationNode();

        if (init)
        {
            TIntermSequence *sequence = init->getSequence();
            TIntermTyped *variable    = (*sequence)[0]->getAsTyped();

            if (variable && variable->getQualifier() == EvqTemporary)
            {
                TIntermBinary *assign = variable->getAsBinaryNode();

                if (assign->getOp() == EOpInitialize)
                {
                    TIntermSymbol *symbol          = assign->getLeft()->getAsSymbolNode();
                    TIntermConstantUnion *constant = assign->getRight()->getAsConstantUnion();

                    if (symbol && constant)
                    {
                        if (constant->getBasicType() == EbtInt && constant->isScalar())
                        {
                            index   = symbol;
                            initial = constant->getIConst(0);
                        }
                    }
                }
            }
        }
    }

    // Parse comparator and limit value
    if (index != nullptr && node->getCondition())
    {
        TIntermBinary *test = node->getCondition()->getAsBinaryNode();

        if (test && test->getLeft()->getAsSymbolNode()->uniqueId() == index->uniqueId())
        {
            TIntermConstantUnion *constant = test->getRight()->getAsConstantUnion();

            if (constant)
            {
                if (constant->getBasicType() == EbtInt && constant->isScalar())
                {
                    comparator = test->getOp();
                    limit      = constant->getIConst(0);
                }
            }
        }
    }

    // Parse increment
    if (index != nullptr && comparator != EOpNull && node->getExpression())
    {
        TIntermBinary *binaryTerminal = node->getExpression()->getAsBinaryNode();
        TIntermUnary *unaryTerminal   = node->getExpression()->getAsUnaryNode();

        if (binaryTerminal)
        {
            TOperator op                   = binaryTerminal->getOp();
            TIntermConstantUnion *constant = binaryTerminal->getRight()->getAsConstantUnion();

            if (constant)
            {
                if (constant->getBasicType() == EbtInt && constant->isScalar())
                {
                    int value = constant->getIConst(0);

                    switch (op)
                    {
                        case EOpAddAssign:
                            increment = value;
                            break;
                        case EOpSubAssign:
                            increment = -value;
                            break;
                        default:
                            UNIMPLEMENTED();
                    }
                }
            }
        }
        else if (unaryTerminal)
        {
            TOperator op = unaryTerminal->getOp();

            switch (op)
            {
                case EOpPostIncrement:
                    increment = 1;
                    break;
                case EOpPostDecrement:
                    increment = -1;
                    break;
                case EOpPreIncrement:
                    increment = 1;
                    break;
                case EOpPreDecrement:
                    increment = -1;
                    break;
                default:
                    UNIMPLEMENTED();
            }
        }
    }

    if (index != nullptr && comparator != EOpNull && increment != 0)
    {
        if (comparator == EOpLessThanEqual)
        {
            comparator = EOpLessThan;
            limit += 1;
        }

        if (comparator == EOpLessThan)
        {
            int iterations = (limit - initial) / increment;

            if (iterations <= MAX_LOOP_ITERATIONS)
            {
                return false;  // Not an excessive loop
            }

            TIntermSymbol *restoreIndex = mExcessiveLoopIndex;
            mExcessiveLoopIndex         = index;

            out << "{int ";
            index->traverse(this);
            out << ";\n"
                   "bool Break";
            index->traverse(this);
            out << " = false;\n";

            bool firstLoopFragment = true;

            while (iterations > 0)
            {
                int clampedLimit = initial + increment * std::min(MAX_LOOP_ITERATIONS, iterations);

                if (!firstLoopFragment)
                {
                    out << "if (!Break";
                    index->traverse(this);
                    out << ") {\n";
                }

                if (iterations <= MAX_LOOP_ITERATIONS)  // Last loop fragment
                {
                    mExcessiveLoopIndex = nullptr;  // Stops setting the Break flag
                }

                // for(int index = initial; index < clampedLimit; index += increment)
                const char *unroll =
                    mCurrentFunctionMetadata->hasGradientInCallGraph(node) ? "LOOP" : "";

                out << unroll << " for(";
                index->traverse(this);
                out << " = ";
                out << initial;

                out << "; ";
                index->traverse(this);
                out << " < ";
                out << clampedLimit;

                out << "; ";
                index->traverse(this);
                out << " += ";
                out << increment;
                out << ")\n";

                outputLineDirective(out, node->getLine().first_line);
                out << "{\n";

                if (node->getBody())
                {
                    node->getBody()->traverse(this);
                }

                outputLineDirective(out, node->getLine().first_line);
                out << ";}\n";

                if (!firstLoopFragment)
                {
                    out << "}\n";
                }

                firstLoopFragment = false;

                initial += MAX_LOOP_ITERATIONS * increment;
                iterations -= MAX_LOOP_ITERATIONS;
            }

            out << "}";

            mExcessiveLoopIndex = restoreIndex;

            return true;
        }
        else
            UNIMPLEMENTED();
    }

    return false;  // Not handled as an excessive loop
}

void OutputHLSL::outputTriplet(TInfoSinkBase &out,
                               Visit visit,
                               const char *preString,
                               const char *inString,
                               const char *postString)
{
    if (visit == PreVisit)
    {
        out << preString;
    }
    else if (visit == InVisit)
    {
        out << inString;
    }
    else if (visit == PostVisit)
    {
        out << postString;
    }
}

void OutputHLSL::outputLineDirective(TInfoSinkBase &out, int line)
{
    if ((mCompileOptions & SH_LINE_DIRECTIVES) && (line > 0))
    {
        out << "\n";
        out << "#line " << line;

        if (mSourcePath)
        {
            out << " \"" << mSourcePath << "\"";
        }

        out << "\n";
    }
}

void OutputHLSL::writeParameter(const TVariable *param, TInfoSinkBase &out)
{
    const TType &type    = param->getType();
    TQualifier qualifier = type.getQualifier();

    TString nameStr = DecorateVariableIfNeeded(*param);
    ASSERT(nameStr != "");  // HLSL demands named arguments, also for prototypes

    if (IsSampler(type.getBasicType()))
    {
        if (mOutputType == SH_HLSL_4_1_OUTPUT)
        {
            // Samplers are passed as indices to the sampler array.
            ASSERT(qualifier != EvqOut && qualifier != EvqInOut);
            out << "const uint " << nameStr << ArrayString(type);
            return;
        }
        if (mOutputType == SH_HLSL_4_0_FL9_3_OUTPUT)
        {
            out << QualifierString(qualifier) << " " << TextureString(type.getBasicType())
                << " texture_" << nameStr << ArrayString(type) << ", " << QualifierString(qualifier)
                << " " << SamplerString(type.getBasicType()) << " sampler_" << nameStr
                << ArrayString(type);
            return;
        }
    }

    // If the parameter is an atomic counter, we need to add an extra parameter to keep track of the
    // buffer offset.
    if (IsAtomicCounter(type.getBasicType()))
    {
        out << QualifierString(qualifier) << " " << TypeString(type) << " " << nameStr << ", int "
            << nameStr << "_offset";
    }
    else
    {
        out << QualifierString(qualifier) << " " << TypeString(type) << " " << nameStr
            << ArrayString(type);
    }

    // If the structure parameter contains samplers, they need to be passed into the function as
    // separate parameters. HLSL doesn't natively support samplers in structs.
    if (type.isStructureContainingSamplers())
    {
        ASSERT(qualifier != EvqOut && qualifier != EvqInOut);
        TVector<const TVariable *> samplerSymbols;
        std::string namePrefix = "angle";
        namePrefix += nameStr.c_str();
        type.createSamplerSymbols(ImmutableString(namePrefix), "", &samplerSymbols, nullptr,
                                  mSymbolTable);
        for (const TVariable *sampler : samplerSymbols)
        {
            const TType &samplerType = sampler->getType();
            if (mOutputType == SH_HLSL_4_1_OUTPUT)
            {
                out << ", const uint " << sampler->name() << ArrayString(samplerType);
            }
            else if (mOutputType == SH_HLSL_4_0_FL9_3_OUTPUT)
            {
                ASSERT(IsSampler(samplerType.getBasicType()));
                out << ", " << QualifierString(qualifier) << " "
                    << TextureString(samplerType.getBasicType()) << " texture_" << sampler->name()
                    << ArrayString(samplerType) << ", " << QualifierString(qualifier) << " "
                    << SamplerString(samplerType.getBasicType()) << " sampler_" << sampler->name()
                    << ArrayString(samplerType);
            }
            else
            {
                ASSERT(IsSampler(samplerType.getBasicType()));
                out << ", " << QualifierString(qualifier) << " " << TypeString(samplerType) << " "
                    << sampler->name() << ArrayString(samplerType);
            }
        }
    }
}

TString OutputHLSL::zeroInitializer(const TType &type) const
{
    TString string;

    size_t size = type.getObjectSize();
    if (size >= kZeroCount)
    {
        mUseZeroArray = true;
    }
    string = GetZeroInitializer(size).c_str();

    return "{" + string + "}";
}

void OutputHLSL::outputConstructor(TInfoSinkBase &out, Visit visit, TIntermAggregate *node)
{
    // Array constructors should have been already pruned from the code.
    ASSERT(!node->getType().isArray());

    if (visit == PreVisit)
    {
        TString constructorName;
        if (node->getBasicType() == EbtStruct)
        {
            constructorName = mStructureHLSL->addStructConstructor(*node->getType().getStruct());
        }
        else
        {
            constructorName =
                mStructureHLSL->addBuiltInConstructor(node->getType(), node->getSequence());
        }
        out << constructorName << "(";
    }
    else if (visit == InVisit)
    {
        out << ", ";
    }
    else if (visit == PostVisit)
    {
        out << ")";
    }
}

const TConstantUnion *OutputHLSL::writeConstantUnion(TInfoSinkBase &out,
                                                     const TType &type,
                                                     const TConstantUnion *const constUnion)
{
    ASSERT(!type.isArray());

    const TConstantUnion *constUnionIterated = constUnion;

    const TStructure *structure = type.getStruct();
    if (structure)
    {
        out << mStructureHLSL->addStructConstructor(*structure) << "(";

        const TFieldList &fields = structure->fields();

        for (size_t i = 0; i < fields.size(); i++)
        {
            const TType *fieldType = fields[i]->type();
            constUnionIterated     = writeConstantUnion(out, *fieldType, constUnionIterated);

            if (i != fields.size() - 1)
            {
                out << ", ";
            }
        }

        out << ")";
    }
    else
    {
        size_t size    = type.getObjectSize();
        bool writeType = size > 1;

        if (writeType)
        {
            out << TypeString(type) << "(";
        }
        constUnionIterated = writeConstantUnionArray(out, constUnionIterated, size);
        if (writeType)
        {
            out << ")";
        }
    }

    return constUnionIterated;
}

void OutputHLSL::writeEmulatedFunctionTriplet(TInfoSinkBase &out, Visit visit, TOperator op)
{
    if (visit == PreVisit)
    {
        const char *opStr = GetOperatorString(op);
        BuiltInFunctionEmulator::WriteEmulatedFunctionName(out, opStr);
        out << "(";
    }
    else
    {
        outputTriplet(out, visit, nullptr, ", ", ")");
    }
}

bool OutputHLSL::writeSameSymbolInitializer(TInfoSinkBase &out,
                                            TIntermSymbol *symbolNode,
                                            TIntermTyped *expression)
{
    ASSERT(symbolNode->variable().symbolType() != SymbolType::Empty);
    const TIntermSymbol *symbolInInitializer = FindSymbolNode(expression, symbolNode->getName());

    if (symbolInInitializer)
    {
        // Type already printed
        out << "t" + str(mUniqueIndex) + " = ";
        expression->traverse(this);
        out << ", ";
        symbolNode->traverse(this);
        out << " = t" + str(mUniqueIndex);

        mUniqueIndex++;
        return true;
    }

    return false;
}

bool OutputHLSL::writeConstantInitialization(TInfoSinkBase &out,
                                             TIntermSymbol *symbolNode,
                                             TIntermTyped *initializer)
{
    if (initializer->hasConstantValue())
    {
        symbolNode->traverse(this);
        out << ArrayString(symbolNode->getType());
        out << " = {";
        writeConstantUnionArray(out, initializer->getConstantValue(),
                                initializer->getType().getObjectSize());
        out << "}";
        return true;
    }
    return false;
}

TString OutputHLSL::addStructEqualityFunction(const TStructure &structure)
{
    const TFieldList &fields = structure.fields();

    for (const auto &eqFunction : mStructEqualityFunctions)
    {
        if (eqFunction->structure == &structure)
        {
            return eqFunction->functionName;
        }
    }

    const TString &structNameString = StructNameString(structure);

    StructEqualityFunction *function = new StructEqualityFunction();
    function->structure              = &structure;
    function->functionName           = "angle_eq_" + structNameString;

    TInfoSinkBase fnOut;

    fnOut << "bool " << function->functionName << "(" << structNameString << " a, "
          << structNameString + " b)\n"
          << "{\n"
             "    return ";

    for (size_t i = 0; i < fields.size(); i++)
    {
        const TField *field    = fields[i];
        const TType *fieldType = field->type();

        const TString &fieldNameA = "a." + Decorate(field->name());
        const TString &fieldNameB = "b." + Decorate(field->name());

        if (i > 0)
        {
            fnOut << " && ";
        }

        fnOut << "(";
        outputEqual(PreVisit, *fieldType, EOpEqual, fnOut);
        fnOut << fieldNameA;
        outputEqual(InVisit, *fieldType, EOpEqual, fnOut);
        fnOut << fieldNameB;
        outputEqual(PostVisit, *fieldType, EOpEqual, fnOut);
        fnOut << ")";
    }

    fnOut << ";\n"
          << "}\n";

    function->functionDefinition = fnOut.c_str();

    mStructEqualityFunctions.push_back(function);
    mEqualityFunctions.push_back(function);

    return function->functionName;
}

TString OutputHLSL::addArrayEqualityFunction(const TType &type)
{
    for (const auto &eqFunction : mArrayEqualityFunctions)
    {
        if (eqFunction->type == type)
        {
            return eqFunction->functionName;
        }
    }

    TType elementType(type);
    elementType.toArrayElementType();

    ArrayHelperFunction *function = new ArrayHelperFunction();
    function->type                = type;

    function->functionName = ArrayHelperFunctionName("angle_eq", type);

    TInfoSinkBase fnOut;

    const TString &typeName = TypeString(type);
    fnOut << "bool " << function->functionName << "(" << typeName << " a" << ArrayString(type)
          << ", " << typeName << " b" << ArrayString(type) << ")\n"
          << "{\n"
             "    for (int i = 0; i < "
          << type.getOutermostArraySize()
          << "; ++i)\n"
             "    {\n"
             "        if (";

    outputEqual(PreVisit, elementType, EOpNotEqual, fnOut);
    fnOut << "a[i]";
    outputEqual(InVisit, elementType, EOpNotEqual, fnOut);
    fnOut << "b[i]";
    outputEqual(PostVisit, elementType, EOpNotEqual, fnOut);

    fnOut << ") { return false; }\n"
             "    }\n"
             "    return true;\n"
             "}\n";

    function->functionDefinition = fnOut.c_str();

    mArrayEqualityFunctions.push_back(function);
    mEqualityFunctions.push_back(function);

    return function->functionName;
}

TString OutputHLSL::addArrayAssignmentFunction(const TType &type)
{
    for (const auto &assignFunction : mArrayAssignmentFunctions)
    {
        if (assignFunction.type == type)
        {
            return assignFunction.functionName;
        }
    }

    TType elementType(type);
    elementType.toArrayElementType();

    ArrayHelperFunction function;
    function.type = type;

    function.functionName = ArrayHelperFunctionName("angle_assign", type);

    TInfoSinkBase fnOut;

    const TString &typeName = TypeString(type);
    fnOut << "void " << function.functionName << "(out " << typeName << " a" << ArrayString(type)
          << ", " << typeName << " b" << ArrayString(type) << ")\n"
          << "{\n"
             "    for (int i = 0; i < "
          << type.getOutermostArraySize()
          << "; ++i)\n"
             "    {\n"
             "        ";

    outputAssign(PreVisit, elementType, fnOut);
    fnOut << "a[i]";
    outputAssign(InVisit, elementType, fnOut);
    fnOut << "b[i]";
    outputAssign(PostVisit, elementType, fnOut);

    fnOut << ";\n"
             "    }\n"
             "}\n";

    function.functionDefinition = fnOut.c_str();

    mArrayAssignmentFunctions.push_back(function);

    return function.functionName;
}

TString OutputHLSL::addArrayConstructIntoFunction(const TType &type)
{
    for (const auto &constructIntoFunction : mArrayConstructIntoFunctions)
    {
        if (constructIntoFunction.type == type)
        {
            return constructIntoFunction.functionName;
        }
    }

    TType elementType(type);
    elementType.toArrayElementType();

    ArrayHelperFunction function;
    function.type = type;

    function.functionName = ArrayHelperFunctionName("angle_construct_into", type);

    TInfoSinkBase fnOut;

    const TString &typeName = TypeString(type);
    fnOut << "void " << function.functionName << "(out " << typeName << " a" << ArrayString(type);
    for (unsigned int i = 0u; i < type.getOutermostArraySize(); ++i)
    {
        fnOut << ", " << typeName << " b" << i << ArrayString(elementType);
    }
    fnOut << ")\n"
             "{\n";

    for (unsigned int i = 0u; i < type.getOutermostArraySize(); ++i)
    {
        fnOut << "    ";
        outputAssign(PreVisit, elementType, fnOut);
        fnOut << "a[" << i << "]";
        outputAssign(InVisit, elementType, fnOut);
        fnOut << "b" << i;
        outputAssign(PostVisit, elementType, fnOut);
        fnOut << ";\n";
    }
    fnOut << "}\n";

    function.functionDefinition = fnOut.c_str();

    mArrayConstructIntoFunctions.push_back(function);

    return function.functionName;
}

void OutputHLSL::ensureStructDefined(const TType &type)
{
    const TStructure *structure = type.getStruct();
    if (structure)
    {
        ASSERT(type.getBasicType() == EbtStruct);
        mStructureHLSL->ensureStructDefined(*structure);
    }
}

bool OutputHLSL::shaderNeedsGenerateOutput() const
{
    return mShaderType == GL_VERTEX_SHADER || mShaderType == GL_FRAGMENT_SHADER;
}

const char *OutputHLSL::generateOutputCall() const
{
    if (mShaderType == GL_VERTEX_SHADER)
    {
        return "generateOutput(input)";
    }
    else
    {
        return "generateOutput()";
    }
}

}  // namespace sh