Remove ANGLE

This marks the end of EGL and OpenGL ES support on Windows.

The concepts of -opengl dynamic, -opengl desktop, QT_OPENGL=software,
etc. remain unchanged, with the exception of the disapperance of
everything ANGLE related.

CMake builds now work identically to qmake on Windows: they default to
'dynamic' OpenGL on Windows, unless -DINPUT_opengl=desktop is specified.

On Windows, Qt 6 is expected to default to the "dynamic" OpenGL model by
default, just like Qt 5.15. This can be changed by switching to "desktop"
OpenGL, which will link to opengl32 (publicly, so other libs and applications
will do so as well) and disallows using another OpenGL DLL.

The "dynamic" mode is essential still because the fallback to a software
rasterizer, such as the opengl32sw.dll we ship with the Qt packages,
has to to work exactly like in Qt 5, the removal of ANGLE does not
change this concept in any way (except of course that the middle option
of using ANGLE is now gone)

When it comes to the windows plugin's OpenGL blacklist feature, it works
like before and accepts the ANGLE/D3D related keywords. They will
then be ignored. Similarly, requesting QT_OPENGL=angle is ignored (but
will show a warning).

The D3D11 and DXGI configure time tests are removed: Qt 5.14 already
depends on D3D 11.1 and DXGI 1.3 headers being available unconditionally
on Win32 (in QRhi's D3D11 backend). No need to test for these.

[ChangeLog][Windows] ANGLE is no longer included with Qt. Dynamic OpenGL
builds work like before but ANGLE is no longer an option. OpenGL proper
or an alternative opengl32 implementation are the two remaining options
now. Attempting to set QT_OPENGL=angle or Qt::AA_UseOpenGLES will have
no effect on Windows.

Fixes: QTBUG-79103
Change-Id: Ia404e0d07f3fe191b27434d863c81180112ecb3b
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>

1 files changed, 0 insertions, 751 deletions

diff --git a/src/3rdparty/angle/src/compiler/translator/EmulatePrecision.cpp b/src/3rdparty/angle/src/compiler/translator/EmulatePrecision.cpp
deleted file mode 100644
index ba09fd77df..0000000000
--- a/src/3rdparty/angle/src/compiler/translator/EmulatePrecision.cpp
+++ /dev/null
@@ -1,751 +0,0 @@
-//
-// 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/EmulatePrecision.h"
-
-#include <memory>
-
-namespace sh
-{
-
-namespace
-{
-
-class RoundingHelperWriter : angle::NonCopyable
-{
-  public:
-    static RoundingHelperWriter *createHelperWriter(const ShShaderOutput outputLanguage);
-
-    void writeCommonRoundingHelpers(TInfoSinkBase &sink, const int shaderVersion);
-    void writeCompoundAssignmentHelper(TInfoSinkBase &sink,
-                                       const char *lType,
-                                       const char *rType,
-                                       const char *opStr,
-                                       const char *opNameStr);
-
-    virtual ~RoundingHelperWriter() {}
-
-  protected:
-    RoundingHelperWriter(const ShShaderOutput outputLanguage) : mOutputLanguage(outputLanguage) {}
-    RoundingHelperWriter() = delete;
-
-    const ShShaderOutput mOutputLanguage;
-
-  private:
-    virtual std::string getTypeString(const char *glslType)     = 0;
-    virtual void writeFloatRoundingHelpers(TInfoSinkBase &sink) = 0;
-    virtual void writeVectorRoundingHelpers(TInfoSinkBase &sink, const unsigned int size) = 0;
-    virtual void writeMatrixRoundingHelper(TInfoSinkBase &sink,
-                                           const unsigned int columns,
-                                           const unsigned int rows,
-                                           const char *functionName) = 0;
-};
-
-class RoundingHelperWriterGLSL : public RoundingHelperWriter
-{
-  public:
-    RoundingHelperWriterGLSL(const ShShaderOutput outputLanguage)
-        : RoundingHelperWriter(outputLanguage)
-    {
-    }
-
-  private:
-    std::string getTypeString(const char *glslType) override;
-    void writeFloatRoundingHelpers(TInfoSinkBase &sink) override;
-    void writeVectorRoundingHelpers(TInfoSinkBase &sink, const unsigned int size) override;
-    void writeMatrixRoundingHelper(TInfoSinkBase &sink,
-                                   const unsigned int columns,
-                                   const unsigned int rows,
-                                   const char *functionName) override;
-};
-
-class RoundingHelperWriterESSL : public RoundingHelperWriterGLSL
-{
-  public:
-    RoundingHelperWriterESSL(const ShShaderOutput outputLanguage)
-        : RoundingHelperWriterGLSL(outputLanguage)
-    {
-    }
-
-  private:
-    std::string getTypeString(const char *glslType) override;
-};
-
-class RoundingHelperWriterHLSL : public RoundingHelperWriter
-{
-  public:
-    RoundingHelperWriterHLSL(const ShShaderOutput outputLanguage)
-        : RoundingHelperWriter(outputLanguage)
-    {
-    }
-
-  private:
-    std::string getTypeString(const char *glslType) override;
-    void writeFloatRoundingHelpers(TInfoSinkBase &sink) override;
-    void writeVectorRoundingHelpers(TInfoSinkBase &sink, const unsigned int size) override;
-    void writeMatrixRoundingHelper(TInfoSinkBase &sink,
-                                   const unsigned int columns,
-                                   const unsigned int rows,
-                                   const char *functionName) override;
-};
-
-RoundingHelperWriter *RoundingHelperWriter::createHelperWriter(const ShShaderOutput outputLanguage)
-{
-    ASSERT(EmulatePrecision::SupportedInLanguage(outputLanguage));
-    switch (outputLanguage)
-    {
-        case SH_HLSL_4_1_OUTPUT:
-            return new RoundingHelperWriterHLSL(outputLanguage);
-        case SH_ESSL_OUTPUT:
-            return new RoundingHelperWriterESSL(outputLanguage);
-        default:
-            return new RoundingHelperWriterGLSL(outputLanguage);
-    }
-}
-
-void RoundingHelperWriter::writeCommonRoundingHelpers(TInfoSinkBase &sink, const int shaderVersion)
-{
-    // Write the angle_frm functions that round floating point numbers to
-    // half precision, and angle_frl functions that round them to minimum lowp
-    // precision.
-
-    writeFloatRoundingHelpers(sink);
-    writeVectorRoundingHelpers(sink, 2);
-    writeVectorRoundingHelpers(sink, 3);
-    writeVectorRoundingHelpers(sink, 4);
-    if (shaderVersion > 100)
-    {
-        for (unsigned int columns = 2; columns <= 4; ++columns)
-        {
-            for (unsigned int rows = 2; rows <= 4; ++rows)
-            {
-                writeMatrixRoundingHelper(sink, columns, rows, "angle_frm");
-                writeMatrixRoundingHelper(sink, columns, rows, "angle_frl");
-            }
-        }
-    }
-    else
-    {
-        for (unsigned int size = 2; size <= 4; ++size)
-        {
-            writeMatrixRoundingHelper(sink, size, size, "angle_frm");
-            writeMatrixRoundingHelper(sink, size, size, "angle_frl");
-        }
-    }
-}
-
-void RoundingHelperWriter::writeCompoundAssignmentHelper(TInfoSinkBase &sink,
-                                                         const char *lType,
-                                                         const char *rType,
-                                                         const char *opStr,
-                                                         const char *opNameStr)
-{
-    std::string lTypeStr = getTypeString(lType);
-    std::string rTypeStr = getTypeString(rType);
-
-    // Note that y should be passed through angle_frm at the function call site,
-    // but x can't be passed through angle_frm there since it is an inout parameter.
-    // So only pass x and the result through angle_frm here.
-    // clang-format off
-    sink <<
-        lTypeStr << " angle_compound_" << opNameStr << "_frm(inout " << lTypeStr << " x, in " << rTypeStr << " y) {\n"
-        "    x = angle_frm(angle_frm(x) " << opStr << " y);\n"
-        "    return x;\n"
-        "}\n";
-    sink <<
-        lTypeStr << " angle_compound_" << opNameStr << "_frl(inout " << lTypeStr << " x, in " << rTypeStr << " y) {\n"
-        "    x = angle_frl(angle_frl(x) " << opStr << " y);\n"
-        "    return x;\n"
-        "}\n";
-    // clang-format on
-}
-
-std::string RoundingHelperWriterGLSL::getTypeString(const char *glslType)
-{
-    return glslType;
-}
-
-std::string RoundingHelperWriterESSL::getTypeString(const char *glslType)
-{
-    std::stringstream typeStrStr;
-    typeStrStr << "highp " << glslType;
-    return typeStrStr.str();
-}
-
-void RoundingHelperWriterGLSL::writeFloatRoundingHelpers(TInfoSinkBase &sink)
-{
-    // Unoptimized version of angle_frm for single floats:
-    //
-    // int webgl_maxNormalExponent(in int exponentBits)
-    // {
-    //     int possibleExponents = int(exp2(float(exponentBits)));
-    //     int exponentBias = possibleExponents / 2 - 1;
-    //     int allExponentBitsOne = possibleExponents - 1;
-    //     return (allExponentBitsOne - 1) - exponentBias;
-    // }
-    //
-    // float angle_frm(in float x)
-    // {
-    //     int mantissaBits = 10;
-    //     int exponentBits = 5;
-    //     float possibleMantissas = exp2(float(mantissaBits));
-    //     float mantissaMax = 2.0 - 1.0 / possibleMantissas;
-    //     int maxNE = webgl_maxNormalExponent(exponentBits);
-    //     float max = exp2(float(maxNE)) * mantissaMax;
-    //     if (x > max)
-    //     {
-    //         return max;
-    //     }
-    //     if (x < -max)
-    //     {
-    //         return -max;
-    //     }
-    //     float exponent = floor(log2(abs(x)));
-    //     if (abs(x) == 0.0 || exponent < -float(maxNE))
-    //     {
-    //         return 0.0 * sign(x)
-    //     }
-    //     x = x * exp2(-(exponent - float(mantissaBits)));
-    //     x = sign(x) * floor(abs(x));
-    //     return x * exp2(exponent - float(mantissaBits));
-    // }
-
-    // All numbers with a magnitude less than 2^-15 are subnormal, and are
-    // flushed to zero.
-
-    // Note the constant numbers below:
-    // a) 65504 is the maximum possible mantissa (1.1111111111 in binary) times
-    //    2^15, the maximum normal exponent.
-    // b) 10.0 is the number of mantissa bits.
-    // c) -25.0 is the minimum normal half-float exponent -15.0 minus the number
-    //    of mantissa bits.
-    // d) + 1e-30 is to make sure the argument of log2() won't be zero. It can
-    //    only affect the result of log2 on x where abs(x) < 1e-22. Since these
-    //    numbers will be flushed to zero either way (2^-15 is the smallest
-    //    normal positive number), this does not introduce any error.
-
-    std::string floatType = getTypeString("float");
-
-    // clang-format off
-    sink <<
-        floatType << " angle_frm(in " << floatType << " x) {\n"
-        "    x = clamp(x, -65504.0, 65504.0);\n"
-        "    " << floatType << " exponent = floor(log2(abs(x) + 1e-30)) - 10.0;\n"
-        "    bool isNonZero = (exponent >= -25.0);\n"
-        "    x = x * exp2(-exponent);\n"
-        "    x = sign(x) * floor(abs(x));\n"
-        "    return x * exp2(exponent) * float(isNonZero);\n"
-        "}\n";
-
-    sink <<
-        floatType << " angle_frl(in " << floatType << " x) {\n"
-        "    x = clamp(x, -2.0, 2.0);\n"
-        "    x = x * 256.0;\n"
-        "    x = sign(x) * floor(abs(x));\n"
-        "    return x * 0.00390625;\n"
-        "}\n";
-    // clang-format on
-}
-
-void RoundingHelperWriterGLSL::writeVectorRoundingHelpers(TInfoSinkBase &sink,
-                                                          const unsigned int size)
-{
-    std::stringstream vecTypeStrStr;
-    vecTypeStrStr << "vec" << size;
-    std::string vecType = getTypeString(vecTypeStrStr.str().c_str());
-
-    // clang-format off
-    sink <<
-        vecType << " angle_frm(in " << vecType << " v) {\n"
-        "    v = clamp(v, -65504.0, 65504.0);\n"
-        "    " << vecType << " exponent = floor(log2(abs(v) + 1e-30)) - 10.0;\n"
-        "    bvec" << size << " isNonZero = greaterThanEqual(exponent, vec" << size << "(-25.0));\n"
-        "    v = v * exp2(-exponent);\n"
-        "    v = sign(v) * floor(abs(v));\n"
-        "    return v * exp2(exponent) * vec" << size << "(isNonZero);\n"
-        "}\n";
-
-    sink <<
-        vecType << " angle_frl(in " << vecType << " v) {\n"
-        "    v = clamp(v, -2.0, 2.0);\n"
-        "    v = v * 256.0;\n"
-        "    v = sign(v) * floor(abs(v));\n"
-        "    return v * 0.00390625;\n"
-        "}\n";
-    // clang-format on
-}
-
-void RoundingHelperWriterGLSL::writeMatrixRoundingHelper(TInfoSinkBase &sink,
-                                                         const unsigned int columns,
-                                                         const unsigned int rows,
-                                                         const char *functionName)
-{
-    std::stringstream matTypeStrStr;
-    matTypeStrStr << "mat" << columns;
-    if (rows != columns)
-    {
-        matTypeStrStr << "x" << rows;
-    }
-    std::string matType = getTypeString(matTypeStrStr.str().c_str());
-
-    sink << matType << " " << functionName << "(in " << matType << " m) {\n"
-         << "    " << matType << " rounded;\n";
-
-    for (unsigned int i = 0; i < columns; ++i)
-    {
-        sink << "    rounded[" << i << "] = " << functionName << "(m[" << i << "]);\n";
-    }
-
-    sink << "    return rounded;\n"
-            "}\n";
-}
-
-static const char *GetHLSLTypeStr(const char *floatTypeStr)
-{
-    if (strcmp(floatTypeStr, "float") == 0)
-    {
-        return "float";
-    }
-    if (strcmp(floatTypeStr, "vec2") == 0)
-    {
-        return "float2";
-    }
-    if (strcmp(floatTypeStr, "vec3") == 0)
-    {
-        return "float3";
-    }
-    if (strcmp(floatTypeStr, "vec4") == 0)
-    {
-        return "float4";
-    }
-    if (strcmp(floatTypeStr, "mat2") == 0)
-    {
-        return "float2x2";
-    }
-    if (strcmp(floatTypeStr, "mat3") == 0)
-    {
-        return "float3x3";
-    }
-    if (strcmp(floatTypeStr, "mat4") == 0)
-    {
-        return "float4x4";
-    }
-    if (strcmp(floatTypeStr, "mat2x3") == 0)
-    {
-        return "float2x3";
-    }
-    if (strcmp(floatTypeStr, "mat2x4") == 0)
-    {
-        return "float2x4";
-    }
-    if (strcmp(floatTypeStr, "mat3x2") == 0)
-    {
-        return "float3x2";
-    }
-    if (strcmp(floatTypeStr, "mat3x4") == 0)
-    {
-        return "float3x4";
-    }
-    if (strcmp(floatTypeStr, "mat4x2") == 0)
-    {
-        return "float4x2";
-    }
-    if (strcmp(floatTypeStr, "mat4x3") == 0)
-    {
-        return "float4x3";
-    }
-    UNREACHABLE();
-    return nullptr;
-}
-
-std::string RoundingHelperWriterHLSL::getTypeString(const char *glslType)
-{
-    return GetHLSLTypeStr(glslType);
-}
-
-void RoundingHelperWriterHLSL::writeFloatRoundingHelpers(TInfoSinkBase &sink)
-{
-    // In HLSL scalars are the same as 1-vectors.
-    writeVectorRoundingHelpers(sink, 1);
-}
-
-void RoundingHelperWriterHLSL::writeVectorRoundingHelpers(TInfoSinkBase &sink,
-                                                          const unsigned int size)
-{
-    std::stringstream vecTypeStrStr;
-    vecTypeStrStr << "float" << size;
-    std::string vecType = vecTypeStrStr.str();
-
-    // clang-format off
-    sink <<
-        vecType << " angle_frm(" << vecType << " v) {\n"
-        "    v = clamp(v, -65504.0, 65504.0);\n"
-        "    " << vecType << " exponent = floor(log2(abs(v) + 1e-30)) - 10.0;\n"
-        "    bool" << size << " isNonZero = exponent < -25.0;\n"
-        "    v = v * exp2(-exponent);\n"
-        "    v = sign(v) * floor(abs(v));\n"
-        "    return v * exp2(exponent) * (float" << size << ")(isNonZero);\n"
-        "}\n";
-
-    sink <<
-        vecType << " angle_frl(" << vecType << " v) {\n"
-        "    v = clamp(v, -2.0, 2.0);\n"
-        "    v = v * 256.0;\n"
-        "    v = sign(v) * floor(abs(v));\n"
-        "    return v * 0.00390625;\n"
-        "}\n";
-    // clang-format on
-}
-
-void RoundingHelperWriterHLSL::writeMatrixRoundingHelper(TInfoSinkBase &sink,
-                                                         const unsigned int columns,
-                                                         const unsigned int rows,
-                                                         const char *functionName)
-{
-    std::stringstream matTypeStrStr;
-    matTypeStrStr << "float" << columns << "x" << rows;
-    std::string matType = matTypeStrStr.str();
-
-    sink << matType << " " << functionName << "(" << matType << " m) {\n"
-         << "    " << matType << " rounded;\n";
-
-    for (unsigned int i = 0; i < columns; ++i)
-    {
-        sink << "    rounded[" << i << "] = " << functionName << "(m[" << i << "]);\n";
-    }
-
-    sink << "    return rounded;\n"
-            "}\n";
-}
-
-bool canRoundFloat(const TType &type)
-{
-    return type.getBasicType() == EbtFloat && !type.isArray() &&
-           (type.getPrecision() == EbpLow || type.getPrecision() == EbpMedium);
-}
-
-TIntermAggregate *createInternalFunctionCallNode(const TType &type,
-                                                 TString name,
-                                                 TIntermSequence *arguments)
-{
-    TName nameObj(name);
-    nameObj.setInternal(true);
-    TIntermAggregate *callNode =
-        TIntermAggregate::Create(type, EOpCallInternalRawFunction, arguments);
-    callNode->getFunctionSymbolInfo()->setNameObj(nameObj);
-    return callNode;
-}
-
-TIntermAggregate *createRoundingFunctionCallNode(TIntermTyped *roundedChild)
-{
-    TString roundFunctionName;
-    if (roundedChild->getPrecision() == EbpMedium)
-        roundFunctionName = "angle_frm";
-    else
-        roundFunctionName      = "angle_frl";
-    TIntermSequence *arguments = new TIntermSequence();
-    arguments->push_back(roundedChild);
-    TIntermAggregate *callNode =
-        createInternalFunctionCallNode(roundedChild->getType(), roundFunctionName, arguments);
-    callNode->getFunctionSymbolInfo()->setKnownToNotHaveSideEffects(true);
-    return callNode;
-}
-
-TIntermAggregate *createCompoundAssignmentFunctionCallNode(TIntermTyped *left,
-                                                           TIntermTyped *right,
-                                                           const char *opNameStr)
-{
-    std::stringstream strstr;
-    if (left->getPrecision() == EbpMedium)
-        strstr << "angle_compound_" << opNameStr << "_frm";
-    else
-        strstr << "angle_compound_" << opNameStr << "_frl";
-    TString functionName       = strstr.str().c_str();
-    TIntermSequence *arguments = new TIntermSequence();
-    arguments->push_back(left);
-    arguments->push_back(right);
-    return createInternalFunctionCallNode(left->getType(), functionName, arguments);
-}
-
-bool ParentUsesResult(TIntermNode *parent, TIntermTyped *node)
-{
-    if (!parent)
-    {
-        return false;
-    }
-
-    TIntermBlock *blockParent = parent->getAsBlock();
-    // If the parent is a block, the result is not assigned anywhere,
-    // so rounding it is not needed. In particular, this can avoid a lot of
-    // unnecessary rounding of unused return values of assignment.
-    if (blockParent)
-    {
-        return false;
-    }
-    TIntermBinary *binaryParent = parent->getAsBinaryNode();
-    if (binaryParent && binaryParent->getOp() == EOpComma && (binaryParent->getRight() != node))
-    {
-        return false;
-    }
-    return true;
-}
-
-bool ParentConstructorTakesCareOfRounding(TIntermNode *parent, TIntermTyped *node)
-{
-    if (!parent)
-    {
-        return false;
-    }
-    TIntermAggregate *parentConstructor = parent->getAsAggregate();
-    if (!parentConstructor || parentConstructor->getOp() != EOpConstruct)
-    {
-        return false;
-    }
-    if (parentConstructor->getPrecision() != node->getPrecision())
-    {
-        return false;
-    }
-    return canRoundFloat(parentConstructor->getType());
-}
-
-}  // namespace anonymous
-
-EmulatePrecision::EmulatePrecision(TSymbolTable *symbolTable, int shaderVersion)
-    : TLValueTrackingTraverser(true, true, true, symbolTable, shaderVersion),
-      mDeclaringVariables(false)
-{
-}
-
-void EmulatePrecision::visitSymbol(TIntermSymbol *node)
-{
-    TIntermNode *parent = getParentNode();
-    if (canRoundFloat(node->getType()) && ParentUsesResult(parent, node) &&
-        !ParentConstructorTakesCareOfRounding(parent, node) && !mDeclaringVariables &&
-        !isLValueRequiredHere())
-    {
-        TIntermNode *replacement = createRoundingFunctionCallNode(node);
-        queueReplacement(replacement, OriginalNode::BECOMES_CHILD);
-    }
-}
-
-bool EmulatePrecision::visitBinary(Visit visit, TIntermBinary *node)
-{
-    bool visitChildren = true;
-
-    TOperator op = node->getOp();
-
-    // RHS of initialize is not being declared.
-    if (op == EOpInitialize && visit == InVisit)
-        mDeclaringVariables = false;
-
-    if ((op == EOpIndexDirectStruct) && visit == InVisit)
-        visitChildren = false;
-
-    if (visit != PreVisit)
-        return visitChildren;
-
-    const TType &type = node->getType();
-    bool roundFloat   = canRoundFloat(type);
-
-    if (roundFloat)
-    {
-        switch (op)
-        {
-            // Math operators that can result in a float may need to apply rounding to the return
-            // value. Note that in the case of assignment, the rounding is applied to its return
-            // value here, not the value being assigned.
-            case EOpAssign:
-            case EOpAdd:
-            case EOpSub:
-            case EOpMul:
-            case EOpDiv:
-            case EOpVectorTimesScalar:
-            case EOpVectorTimesMatrix:
-            case EOpMatrixTimesVector:
-            case EOpMatrixTimesScalar:
-            case EOpMatrixTimesMatrix:
-            {
-                TIntermNode *parent = getParentNode();
-                if (!ParentUsesResult(parent, node) ||
-                    ParentConstructorTakesCareOfRounding(parent, node))
-                {
-                    break;
-                }
-                TIntermNode *replacement = createRoundingFunctionCallNode(node);
-                queueReplacement(replacement, OriginalNode::BECOMES_CHILD);
-                break;
-            }
-
-            // Compound assignment cases need to replace the operator with a function call.
-            case EOpAddAssign:
-            {
-                mEmulateCompoundAdd.insert(
-                    TypePair(type.getBuiltInTypeNameString(),
-                             node->getRight()->getType().getBuiltInTypeNameString()));
-                TIntermNode *replacement = createCompoundAssignmentFunctionCallNode(
-                    node->getLeft(), node->getRight(), "add");
-                queueReplacement(replacement, OriginalNode::IS_DROPPED);
-                break;
-            }
-            case EOpSubAssign:
-            {
-                mEmulateCompoundSub.insert(
-                    TypePair(type.getBuiltInTypeNameString(),
-                             node->getRight()->getType().getBuiltInTypeNameString()));
-                TIntermNode *replacement = createCompoundAssignmentFunctionCallNode(
-                    node->getLeft(), node->getRight(), "sub");
-                queueReplacement(replacement, OriginalNode::IS_DROPPED);
-                break;
-            }
-            case EOpMulAssign:
-            case EOpVectorTimesMatrixAssign:
-            case EOpVectorTimesScalarAssign:
-            case EOpMatrixTimesScalarAssign:
-            case EOpMatrixTimesMatrixAssign:
-            {
-                mEmulateCompoundMul.insert(
-                    TypePair(type.getBuiltInTypeNameString(),
-                             node->getRight()->getType().getBuiltInTypeNameString()));
-                TIntermNode *replacement = createCompoundAssignmentFunctionCallNode(
-                    node->getLeft(), node->getRight(), "mul");
-                queueReplacement(replacement, OriginalNode::IS_DROPPED);
-                break;
-            }
-            case EOpDivAssign:
-            {
-                mEmulateCompoundDiv.insert(
-                    TypePair(type.getBuiltInTypeNameString(),
-                             node->getRight()->getType().getBuiltInTypeNameString()));
-                TIntermNode *replacement = createCompoundAssignmentFunctionCallNode(
-                    node->getLeft(), node->getRight(), "div");
-                queueReplacement(replacement, OriginalNode::IS_DROPPED);
-                break;
-            }
-            default:
-                // The rest of the binary operations should not need precision emulation.
-                break;
-        }
-    }
-    return visitChildren;
-}
-
-bool EmulatePrecision::visitDeclaration(Visit visit, TIntermDeclaration *node)
-{
-    // Variable or interface block declaration.
-    if (visit == PreVisit)
-    {
-        mDeclaringVariables = true;
-    }
-    else if (visit == InVisit)
-    {
-        mDeclaringVariables = true;
-    }
-    else
-    {
-        mDeclaringVariables = false;
-    }
-    return true;
-}
-
-bool EmulatePrecision::visitInvariantDeclaration(Visit visit, TIntermInvariantDeclaration *node)
-{
-    return false;
-}
-
-bool EmulatePrecision::visitFunctionPrototype(Visit visit, TIntermFunctionPrototype *node)
-{
-    return false;
-}
-
-bool EmulatePrecision::visitAggregate(Visit visit, TIntermAggregate *node)
-{
-    if (visit != PreVisit)
-        return true;
-    switch (node->getOp())
-    {
-        case EOpCallInternalRawFunction:
-        case EOpCallFunctionInAST:
-            // User-defined function return values are not rounded. The calculations that produced
-            // the value inside the function definition should have been rounded.
-            break;
-        case EOpConstruct:
-            if (node->getBasicType() == EbtStruct)
-            {
-                break;
-            }
-        default:
-            TIntermNode *parent = getParentNode();
-            if (canRoundFloat(node->getType()) && ParentUsesResult(parent, node) &&
-                !ParentConstructorTakesCareOfRounding(parent, node))
-            {
-                TIntermNode *replacement = createRoundingFunctionCallNode(node);
-                queueReplacement(replacement, OriginalNode::BECOMES_CHILD);
-            }
-            break;
-    }
-    return true;
-}
-
-bool EmulatePrecision::visitUnary(Visit visit, TIntermUnary *node)
-{
-    switch (node->getOp())
-    {
-        case EOpNegative:
-        case EOpLogicalNot:
-        case EOpPostIncrement:
-        case EOpPostDecrement:
-        case EOpPreIncrement:
-        case EOpPreDecrement:
-        case EOpLogicalNotComponentWise:
-            break;
-        default:
-            if (canRoundFloat(node->getType()) && visit == PreVisit)
-            {
-                TIntermNode *replacement = createRoundingFunctionCallNode(node);
-                queueReplacement(replacement, OriginalNode::BECOMES_CHILD);
-            }
-            break;
-    }
-
-    return true;
-}
-
-void EmulatePrecision::writeEmulationHelpers(TInfoSinkBase &sink,
-                                             const int shaderVersion,
-                                             const ShShaderOutput outputLanguage)
-{
-    std::unique_ptr<RoundingHelperWriter> roundingHelperWriter(
-        RoundingHelperWriter::createHelperWriter(outputLanguage));
-
-    roundingHelperWriter->writeCommonRoundingHelpers(sink, shaderVersion);
-
-    EmulationSet::const_iterator it;
-    for (it = mEmulateCompoundAdd.begin(); it != mEmulateCompoundAdd.end(); it++)
-        roundingHelperWriter->writeCompoundAssignmentHelper(sink, it->lType, it->rType, "+", "add");
-    for (it = mEmulateCompoundSub.begin(); it != mEmulateCompoundSub.end(); it++)
-        roundingHelperWriter->writeCompoundAssignmentHelper(sink, it->lType, it->rType, "-", "sub");
-    for (it = mEmulateCompoundDiv.begin(); it != mEmulateCompoundDiv.end(); it++)
-        roundingHelperWriter->writeCompoundAssignmentHelper(sink, it->lType, it->rType, "/", "div");
-    for (it = mEmulateCompoundMul.begin(); it != mEmulateCompoundMul.end(); it++)
-        roundingHelperWriter->writeCompoundAssignmentHelper(sink, it->lType, it->rType, "*", "mul");
-}
-
-// static
-bool EmulatePrecision::SupportedInLanguage(const ShShaderOutput outputLanguage)
-{
-    switch (outputLanguage)
-    {
-        case SH_HLSL_4_1_OUTPUT:
-        case SH_ESSL_OUTPUT:
-            return true;
-        default:
-            // Other languages not yet supported
-            return (outputLanguage == SH_GLSL_COMPATIBILITY_OUTPUT ||
-                    sh::IsGLSL130OrNewer(outputLanguage));
-    }
-}
-
-}  // namespace sh