tor-browser

ProgramLinkedResources.cpp (89034B)

---

//
// Copyright 2017 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.
//

// ProgramLinkedResources.cpp: implements link-time checks for default block uniforms, and generates
// uniform locations. Populates data structures related to uniforms so that they can be stored in
// program state.

#include "libANGLE/ProgramLinkedResources.h"

#include "common/string_utils.h"
#include "common/utilities.h"
#include "libANGLE/Caps.h"
#include "libANGLE/Context.h"
#include "libANGLE/Shader.h"
#include "libANGLE/features.h"

namespace gl
{
namespace
{
LinkedUniform *FindUniform(std::vector<LinkedUniform> &list, const std::string &name)
{
   for (LinkedUniform &uniform : list)
   {
       if (uniform.name == name)
           return &uniform;
   }

   return nullptr;
}

template <typename VarT>
void SetActive(std::vector<VarT> *list, const std::string &name, ShaderType shaderType, bool active)
{
   for (auto &variable : *list)
   {
       if (variable.name == name)
       {
           variable.setActive(shaderType, active);
           return;
       }
   }
}

// GLSL ES Spec 3.00.3, section 4.3.5.
LinkMismatchError LinkValidateUniforms(const sh::ShaderVariable &uniform1,
                                      const sh::ShaderVariable &uniform2,
                                      std::string *mismatchedStructFieldName)
{
#if ANGLE_PROGRAM_LINK_VALIDATE_UNIFORM_PRECISION == ANGLE_ENABLED
   const bool validatePrecisionFeature = true;
#else
   const bool validatePrecisionFeature = false;
#endif

   // Validate precision match of uniforms iff they are statically used
   bool validatePrecision = uniform1.staticUse && uniform2.staticUse && validatePrecisionFeature;
   LinkMismatchError linkError = LinkValidateProgramVariables(
       uniform1, uniform2, validatePrecision, false, false, mismatchedStructFieldName);
   if (linkError != LinkMismatchError::NO_MISMATCH)
   {
       return linkError;
   }

   // GLSL ES Spec 3.10.4, section 4.4.5.
   if (uniform1.binding != -1 && uniform2.binding != -1 && uniform1.binding != uniform2.binding)
   {
       return LinkMismatchError::BINDING_MISMATCH;
   }

   // GLSL ES Spec 3.10.4, section 9.2.1.
   if (uniform1.location != -1 && uniform2.location != -1 &&
       uniform1.location != uniform2.location)
   {
       return LinkMismatchError::LOCATION_MISMATCH;
   }
   if (uniform1.offset != uniform2.offset)
   {
       return LinkMismatchError::OFFSET_MISMATCH;
   }

   return LinkMismatchError::NO_MISMATCH;
}

GLuint GetMaximumShaderUniformVectors(ShaderType shaderType, const Caps &caps)
{
   switch (shaderType)
   {
       case ShaderType::Vertex:
           return static_cast<GLuint>(caps.maxVertexUniformVectors);
       case ShaderType::Fragment:
           return static_cast<GLuint>(caps.maxFragmentUniformVectors);

       case ShaderType::Compute:
       case ShaderType::Geometry:
       case ShaderType::TessControl:
       case ShaderType::TessEvaluation:
           return static_cast<GLuint>(caps.maxShaderUniformComponents[shaderType]) / 4;

       default:
           UNREACHABLE();
           return 0u;
   }
}

enum class UniformType : uint8_t
{
   Variable      = 0,
   Sampler       = 1,
   Image         = 2,
   AtomicCounter = 3,

   InvalidEnum = 4,
   EnumCount   = 4,
};

const char *GetUniformResourceNameString(UniformType uniformType)
{
   switch (uniformType)
   {
       case UniformType::Variable:
           return "uniform";
       case UniformType::Sampler:
           return "texture image unit";
       case UniformType::Image:
           return "image uniform";
       case UniformType::AtomicCounter:
           return "atomic counter";
       default:
           UNREACHABLE();
           return "";
   }
}

std::string GetUniformResourceLimitName(ShaderType shaderType, UniformType uniformType)
{
   // Special case: MAX_TEXTURE_IMAGE_UNITS (no "MAX_FRAGMENT_TEXTURE_IMAGE_UNITS")
   if (shaderType == ShaderType::Fragment && uniformType == UniformType::Sampler)
   {
       return "MAX_TEXTURE_IMAGE_UNITS";
   }

   std::ostringstream ostream;
   ostream << "MAX_" << GetShaderTypeString(shaderType) << "_";

   switch (uniformType)
   {
       case UniformType::Variable:
           // For vertex and fragment shaders, ES 2.0 only defines MAX_VERTEX_UNIFORM_VECTORS and
           // MAX_FRAGMENT_UNIFORM_VECTORS ([OpenGL ES 2.0] Table 6.20).
           if (shaderType == ShaderType::Vertex || shaderType == ShaderType::Fragment)
           {
               ostream << "UNIFORM_VECTORS";
               break;
           }
           // For compute and geometry shaders, there are no definitions on
           // "MAX_COMPUTE_UNIFORM_VECTORS" or "MAX_GEOMETRY_UNIFORM_VECTORS_EXT"
           // ([OpenGL ES 3.1] Table 20.45, [EXT_geometry_shader] Table 20.43gs).
           else
           {
               ostream << "UNIFORM_COMPONENTS";
           }
           break;
       case UniformType::Sampler:
           ostream << "TEXTURE_IMAGE_UNITS";
           break;
       case UniformType::Image:
           ostream << "IMAGE_UNIFORMS";
           break;
       case UniformType::AtomicCounter:
           ostream << "ATOMIC_COUNTERS";
           break;
       default:
           UNREACHABLE();
           return "";
   }

   if (shaderType == ShaderType::Geometry)
   {
       ostream << "_EXT";
   }

   return ostream.str();
}

void LogUniformsExceedLimit(ShaderType shaderType,
                           UniformType uniformType,
                           GLuint limit,
                           InfoLog &infoLog)
{
   infoLog << GetShaderTypeString(shaderType) << " shader "
           << GetUniformResourceNameString(uniformType) << "s count exceeds "
           << GetUniformResourceLimitName(shaderType, uniformType) << "(" << limit << ")";
}

// The purpose of this visitor is to capture the uniforms in a uniform block. Each new uniform is
// added to "uniformsOut".
class UniformBlockEncodingVisitor : public sh::VariableNameVisitor
{
 public:
   UniformBlockEncodingVisitor(const GetBlockMemberInfoFunc &getMemberInfo,
                               const std::string &namePrefix,
                               const std::string &mappedNamePrefix,
                               std::vector<LinkedUniform> *uniformsOut,
                               ShaderType shaderType,
                               int blockIndex)
       : sh::VariableNameVisitor(namePrefix, mappedNamePrefix),
         mGetMemberInfo(getMemberInfo),
         mUniformsOut(uniformsOut),
         mShaderType(shaderType),
         mBlockIndex(blockIndex)
   {}

   void visitNamedVariable(const sh::ShaderVariable &variable,
                           bool isRowMajor,
                           const std::string &name,
                           const std::string &mappedName,
                           const std::vector<unsigned int> &arraySizes) override
   {
       // If getBlockMemberInfo returns false, the variable is optimized out.
       sh::BlockMemberInfo variableInfo;
       if (!mGetMemberInfo(name, mappedName, &variableInfo))
           return;

       std::string nameWithArrayIndex       = name;
       std::string mappedNameWithArrayIndex = mappedName;

       if (variable.isArray())
       {
           nameWithArrayIndex += "[0]";
           mappedNameWithArrayIndex += "[0]";
       }

       if (mBlockIndex == -1)
       {
           SetActive(mUniformsOut, nameWithArrayIndex, mShaderType, variable.active);
           return;
       }

       LinkedUniform newUniform(variable.type, variable.precision, nameWithArrayIndex,
                                variable.arraySizes, -1, -1, -1, mBlockIndex, variableInfo);
       newUniform.mappedName = mappedNameWithArrayIndex;
       newUniform.setActive(mShaderType, variable.active);

       // Since block uniforms have no location, we don't need to store them in the uniform
       // locations list.
       mUniformsOut->push_back(newUniform);
   }

 private:
   const GetBlockMemberInfoFunc &mGetMemberInfo;
   std::vector<LinkedUniform> *mUniformsOut;
   const ShaderType mShaderType;
   const int mBlockIndex;
};

// The purpose of this visitor is to capture the buffer variables in a shader storage block. Each
// new buffer variable is stored in "bufferVariablesOut".
class ShaderStorageBlockVisitor : public sh::BlockEncoderVisitor
{
 public:
   ShaderStorageBlockVisitor(const GetBlockMemberInfoFunc &getMemberInfo,
                             const std::string &namePrefix,
                             const std::string &mappedNamePrefix,
                             std::vector<BufferVariable> *bufferVariablesOut,
                             ShaderType shaderType,
                             int blockIndex)
       : sh::BlockEncoderVisitor(namePrefix, mappedNamePrefix, &mStubEncoder),
         mGetMemberInfo(getMemberInfo),
         mBufferVariablesOut(bufferVariablesOut),
         mShaderType(shaderType),
         mBlockIndex(blockIndex)
   {}

   void visitNamedVariable(const sh::ShaderVariable &variable,
                           bool isRowMajor,
                           const std::string &name,
                           const std::string &mappedName,
                           const std::vector<unsigned int> &arraySizes) override
   {
       if (mSkipEnabled)
           return;

       // If getBlockMemberInfo returns false, the variable is optimized out.
       sh::BlockMemberInfo variableInfo;
       if (!mGetMemberInfo(name, mappedName, &variableInfo))
           return;

       std::string nameWithArrayIndex       = name;
       std::string mappedNameWithArrayIndex = mappedName;

       if (variable.isArray())
       {
           nameWithArrayIndex += "[0]";
           mappedNameWithArrayIndex += "[0]";
       }

       if (mBlockIndex == -1)
       {
           SetActive(mBufferVariablesOut, nameWithArrayIndex, mShaderType, variable.active);
           return;
       }

       BufferVariable newBufferVariable(variable.type, variable.precision, nameWithArrayIndex,
                                        variable.arraySizes, mBlockIndex, variableInfo);
       newBufferVariable.mappedName = mappedNameWithArrayIndex;
       newBufferVariable.setActive(mShaderType, variable.active);

       newBufferVariable.topLevelArraySize = mTopLevelArraySize;

       mBufferVariablesOut->push_back(newBufferVariable);
   }

 private:
   const GetBlockMemberInfoFunc &mGetMemberInfo;
   std::vector<BufferVariable> *mBufferVariablesOut;
   const ShaderType mShaderType;
   const int mBlockIndex;
   sh::StubBlockEncoder mStubEncoder;
};

struct ShaderUniformCount
{
   unsigned int vectorCount        = 0;
   unsigned int samplerCount       = 0;
   unsigned int imageCount         = 0;
   unsigned int atomicCounterCount = 0;
   unsigned int fragmentInOutCount = 0;
};

ShaderUniformCount &operator+=(ShaderUniformCount &lhs, const ShaderUniformCount &rhs)
{
   lhs.vectorCount += rhs.vectorCount;
   lhs.samplerCount += rhs.samplerCount;
   lhs.imageCount += rhs.imageCount;
   lhs.atomicCounterCount += rhs.atomicCounterCount;
   lhs.fragmentInOutCount += rhs.fragmentInOutCount;
   return lhs;
}

// The purpose of this visitor is to flatten struct and array uniforms into a list of singleton
// uniforms. They are stored in separate lists by uniform type so they can be sorted in order.
// Counts for each uniform category are stored and can be queried with "getCounts".
class FlattenUniformVisitor : public sh::VariableNameVisitor
{
 public:
   FlattenUniformVisitor(ShaderType shaderType,
                         const sh::ShaderVariable &uniform,
                         std::vector<LinkedUniform> *uniforms,
                         std::vector<LinkedUniform> *samplerUniforms,
                         std::vector<LinkedUniform> *imageUniforms,
                         std::vector<LinkedUniform> *atomicCounterUniforms,
                         std::vector<LinkedUniform> *inputAttachmentUniforms,
                         std::vector<UnusedUniform> *unusedUniforms)
       : sh::VariableNameVisitor("", ""),
         mShaderType(shaderType),
         mMarkActive(uniform.active),
         mMarkStaticUse(uniform.staticUse),
         mBinding(uniform.binding),
         mOffset(uniform.offset),
         mLocation(uniform.location),
         mUniforms(uniforms),
         mSamplerUniforms(samplerUniforms),
         mImageUniforms(imageUniforms),
         mAtomicCounterUniforms(atomicCounterUniforms),
         mInputAttachmentUniforms(inputAttachmentUniforms),
         mUnusedUniforms(unusedUniforms)
   {}

   void visitNamedOpaqueObject(const sh::ShaderVariable &variable,
                               const std::string &name,
                               const std::string &mappedName,
                               const std::vector<unsigned int> &arraySizes) override
   {
       visitNamedVariable(variable, false, name, mappedName, arraySizes);
   }

   void visitNamedVariable(const sh::ShaderVariable &variable,
                           bool isRowMajor,
                           const std::string &name,
                           const std::string &mappedName,
                           const std::vector<unsigned int> &arraySizes) override
   {
       bool isSampler                          = IsSamplerType(variable.type);
       bool isImage                            = IsImageType(variable.type);
       bool isAtomicCounter                    = IsAtomicCounterType(variable.type);
       bool isFragmentInOut                    = variable.isFragmentInOut;
       std::vector<LinkedUniform> *uniformList = mUniforms;
       if (isSampler)
       {
           uniformList = mSamplerUniforms;
       }
       else if (isImage)
       {
           uniformList = mImageUniforms;
       }
       else if (isAtomicCounter)
       {
           uniformList = mAtomicCounterUniforms;
       }
       else if (isFragmentInOut)
       {
           uniformList = mInputAttachmentUniforms;
       }

       std::string fullNameWithArrayIndex(name);
       std::string fullMappedNameWithArrayIndex(mappedName);

       if (variable.isArray())
       {
           // We're following the GLES 3.1 November 2016 spec section 7.3.1.1 Naming Active
           // Resources and including [0] at the end of array variable names.
           fullNameWithArrayIndex += "[0]";
           fullMappedNameWithArrayIndex += "[0]";
       }

       LinkedUniform *existingUniform = FindUniform(*uniformList, fullNameWithArrayIndex);
       if (existingUniform)
       {
           if (getBinding() != -1)
           {
               existingUniform->binding = getBinding();
           }
           if (getOffset() != -1)
           {
               existingUniform->offset = getOffset();
           }
           if (mLocation != -1)
           {
               existingUniform->location = mLocation;
           }
           if (mMarkActive)
           {
               existingUniform->active = true;
               existingUniform->setActive(mShaderType, true);
           }
           if (mMarkStaticUse)
           {
               existingUniform->staticUse = true;
           }
       }
       else
       {
           LinkedUniform linkedUniform(variable.type, variable.precision, fullNameWithArrayIndex,
                                       variable.arraySizes, getBinding(), getOffset(), mLocation,
                                       -1, sh::kDefaultBlockMemberInfo);
           linkedUniform.mappedName          = fullMappedNameWithArrayIndex;
           linkedUniform.active              = mMarkActive;
           linkedUniform.staticUse           = mMarkStaticUse;
           linkedUniform.outerArraySizes     = arraySizes;
           linkedUniform.texelFetchStaticUse = variable.texelFetchStaticUse;
           linkedUniform.imageUnitFormat     = variable.imageUnitFormat;
           linkedUniform.isFragmentInOut     = variable.isFragmentInOut;
           if (variable.hasParentArrayIndex())
           {
               linkedUniform.setParentArrayIndex(variable.parentArrayIndex());
           }

           std::vector<unsigned int> arrayDims = arraySizes;
           ASSERT(variable.arraySizes.size() == 1 || variable.arraySizes.size() == 0);
           arrayDims.push_back(variable.arraySizes.empty() ? 1 : variable.arraySizes[0]);

           size_t numDimensions = arraySizes.size();
           uint32_t arrayStride = 1;
           for (size_t dimension = numDimensions; dimension > 0;)
           {
               --dimension;
               arrayStride *= arrayDims[dimension + 1];
               linkedUniform.outerArrayOffset += arrayStride * mArrayElementStack[dimension];
           }

           if (mMarkActive)
           {
               linkedUniform.setActive(mShaderType, true);
           }
           else
           {
               mUnusedUniforms->emplace_back(
                   linkedUniform.name, linkedUniform.isSampler(), linkedUniform.isImage(),
                   linkedUniform.isAtomicCounter(), linkedUniform.isFragmentInOut);
           }

           uniformList->push_back(linkedUniform);
       }

       unsigned int elementCount = variable.getBasicTypeElementCount();

       // Samplers and images aren't "real" uniforms, so they don't count towards register usage.
       // Likewise, don't count "real" uniforms towards opaque count.

       if (!IsOpaqueType(variable.type) && !isFragmentInOut)
       {
           mUniformCount.vectorCount += VariableRegisterCount(variable.type) * elementCount;
       }

       mUniformCount.samplerCount += (isSampler ? elementCount : 0);
       mUniformCount.imageCount += (isImage ? elementCount : 0);
       mUniformCount.atomicCounterCount += (isAtomicCounter ? elementCount : 0);
       mUniformCount.fragmentInOutCount += (isFragmentInOut ? elementCount : 0);

       if (mLocation != -1)
       {
           mLocation += elementCount;
       }
   }

   void enterStructAccess(const sh::ShaderVariable &structVar, bool isRowMajor) override
   {
       mStructStackSize++;
       sh::VariableNameVisitor::enterStructAccess(structVar, isRowMajor);
   }

   void exitStructAccess(const sh::ShaderVariable &structVar, bool isRowMajor) override
   {
       mStructStackSize--;
       sh::VariableNameVisitor::exitStructAccess(structVar, isRowMajor);
   }

   void enterArrayElement(const sh::ShaderVariable &arrayVar, unsigned int arrayElement) override
   {
       mArrayElementStack.push_back(arrayElement);
       sh::VariableNameVisitor::enterArrayElement(arrayVar, arrayElement);
   }

   void exitArrayElement(const sh::ShaderVariable &arrayVar, unsigned int arrayElement) override
   {
       mArrayElementStack.pop_back();
       sh::VariableNameVisitor::exitArrayElement(arrayVar, arrayElement);
   }

   ShaderUniformCount getCounts() const { return mUniformCount; }

 private:
   int getBinding() const { return mStructStackSize == 0 ? mBinding : -1; }
   int getOffset() const { return mStructStackSize == 0 ? mOffset : -1; }

   ShaderType mShaderType;

   // Active and StaticUse are given separately because they are tracked at struct granularity.
   bool mMarkActive;
   bool mMarkStaticUse;
   int mBinding;
   int mOffset;
   int mLocation;
   std::vector<LinkedUniform> *mUniforms;
   std::vector<LinkedUniform> *mSamplerUniforms;
   std::vector<LinkedUniform> *mImageUniforms;
   std::vector<LinkedUniform> *mAtomicCounterUniforms;
   std::vector<LinkedUniform> *mInputAttachmentUniforms;
   std::vector<UnusedUniform> *mUnusedUniforms;
   std::vector<unsigned int> mArrayElementStack;
   ShaderUniformCount mUniformCount;
   unsigned int mStructStackSize = 0;
};

class InterfaceBlockInfo final : angle::NonCopyable
{
 public:
   InterfaceBlockInfo(CustomBlockLayoutEncoderFactory *customEncoderFactory)
       : mCustomEncoderFactory(customEncoderFactory)
   {}

   void getShaderBlockInfo(const std::vector<sh::InterfaceBlock> &interfaceBlocks);

   bool getBlockSize(const std::string &name, const std::string &mappedName, size_t *sizeOut);
   bool getBlockMemberInfo(const std::string &name,
                           const std::string &mappedName,
                           sh::BlockMemberInfo *infoOut);

 private:
   size_t getBlockInfo(const sh::InterfaceBlock &interfaceBlock);

   std::map<std::string, size_t> mBlockSizes;
   sh::BlockLayoutMap mBlockLayout;
   // Based on the interface block layout, the std140 or std430 encoders are used.  On some
   // platforms (currently only D3D), there could be another non-standard encoder used.
   CustomBlockLayoutEncoderFactory *mCustomEncoderFactory;
};

void InterfaceBlockInfo::getShaderBlockInfo(const std::vector<sh::InterfaceBlock> &interfaceBlocks)
{
   for (const sh::InterfaceBlock &interfaceBlock : interfaceBlocks)
   {
       if (!IsActiveInterfaceBlock(interfaceBlock))
           continue;

       if (mBlockSizes.count(interfaceBlock.name) > 0)
           continue;

       size_t dataSize                  = getBlockInfo(interfaceBlock);
       mBlockSizes[interfaceBlock.name] = dataSize;
   }
}

size_t InterfaceBlockInfo::getBlockInfo(const sh::InterfaceBlock &interfaceBlock)
{
   ASSERT(IsActiveInterfaceBlock(interfaceBlock));

   // define member uniforms
   sh::Std140BlockEncoder std140Encoder;
   sh::Std430BlockEncoder std430Encoder;
   sh::BlockLayoutEncoder *customEncoder = nullptr;
   sh::BlockLayoutEncoder *encoder       = nullptr;

   if (interfaceBlock.layout == sh::BLOCKLAYOUT_STD140)
   {
       encoder = &std140Encoder;
   }
   else if (interfaceBlock.layout == sh::BLOCKLAYOUT_STD430)
   {
       encoder = &std430Encoder;
   }
   else if (mCustomEncoderFactory)
   {
       encoder = customEncoder = mCustomEncoderFactory->makeEncoder();
   }
   else
   {
       UNREACHABLE();
       return 0;
   }

   sh::GetInterfaceBlockInfo(interfaceBlock.fields, interfaceBlock.fieldPrefix(), encoder,
                             &mBlockLayout);

   size_t offset = encoder->getCurrentOffset();

   SafeDelete(customEncoder);

   return offset;
}

bool InterfaceBlockInfo::getBlockSize(const std::string &name,
                                     const std::string &mappedName,
                                     size_t *sizeOut)
{
   size_t nameLengthWithoutArrayIndex;
   ParseArrayIndex(name, &nameLengthWithoutArrayIndex);
   std::string baseName = name.substr(0u, nameLengthWithoutArrayIndex);
   auto sizeIter        = mBlockSizes.find(baseName);
   if (sizeIter == mBlockSizes.end())
   {
       *sizeOut = 0;
       return false;
   }

   *sizeOut = sizeIter->second;
   return true;
}

bool InterfaceBlockInfo::getBlockMemberInfo(const std::string &name,
                                           const std::string &mappedName,
                                           sh::BlockMemberInfo *infoOut)
{
   auto infoIter = mBlockLayout.find(name);
   if (infoIter == mBlockLayout.end())
   {
       *infoOut = sh::kDefaultBlockMemberInfo;
       return false;
   }

   *infoOut = infoIter->second;
   return true;
}

void GetFilteredVaryings(const std::vector<sh::ShaderVariable> &varyings,
                        std::vector<const sh::ShaderVariable *> *filteredVaryingsOut)
{
   for (const sh::ShaderVariable &varying : varyings)
   {
       // Built-in varyings obey special rules
       if (varying.isBuiltIn())
       {
           continue;
       }

       filteredVaryingsOut->push_back(&varying);
   }
}

LinkMismatchError LinkValidateVaryings(const sh::ShaderVariable &outputVarying,
                                      const sh::ShaderVariable &inputVarying,
                                      int shaderVersion,
                                      ShaderType frontShaderType,
                                      ShaderType backShaderType,
                                      bool isSeparable,
                                      std::string *mismatchedStructFieldName)
{
   // [ES 3.2 spec] 7.4.1 Shader Interface Matching:
   // Tessellation control shader per-vertex output variables and blocks and tessellation control,
   // tessellation evaluation, and geometry shader per-vertex input variables and blocks are
   // required to be declared as arrays, with each element representing input or output values for
   // a single vertex of a multi-vertex primitive. For the purposes of interface matching, such
   // variables and blocks are treated as though they were not declared as arrays.
   bool treatOutputAsNonArray =
       (frontShaderType == ShaderType::TessControl && !outputVarying.isPatch);
   bool treatInputAsNonArray =
       ((backShaderType == ShaderType::TessControl ||
         backShaderType == ShaderType::TessEvaluation || backShaderType == ShaderType::Geometry) &&
        !inputVarying.isPatch);

   // Skip the validation on the array sizes between a vertex output varying and a geometry input
   // varying as it has been done before.
   bool validatePrecision      = isSeparable && (shaderVersion > 100);
   LinkMismatchError linkError = LinkValidateProgramVariables(
       outputVarying, inputVarying, validatePrecision, treatOutputAsNonArray, treatInputAsNonArray,
       mismatchedStructFieldName);
   if (linkError != LinkMismatchError::NO_MISMATCH)
   {
       return linkError;
   }

   // Explicit locations must match if the names match.
   if (outputVarying.isSameNameAtLinkTime(inputVarying) &&
       outputVarying.location != inputVarying.location)
   {
       return LinkMismatchError::LOCATION_MISMATCH;
   }

   if (!sh::InterpolationTypesMatch(outputVarying.interpolation, inputVarying.interpolation))
   {
       return LinkMismatchError::INTERPOLATION_TYPE_MISMATCH;
   }

   if (shaderVersion == 100 && outputVarying.isInvariant != inputVarying.isInvariant)
   {
       return LinkMismatchError::INVARIANCE_MISMATCH;
   }

   return LinkMismatchError::NO_MISMATCH;
}

bool DoShaderVariablesMatch(int frontShaderVersion,
                           ShaderType frontShaderType,
                           ShaderType backShaderType,
                           const sh::ShaderVariable &input,
                           const sh::ShaderVariable &output,
                           bool isSeparable,
                           gl::InfoLog &infoLog)
{
   bool namesMatch     = input.isSameNameAtLinkTime(output);
   bool locationsMatch = input.location != -1 && input.location == output.location;

   // An output block is considered to match an input block in the subsequent
   // shader if the two blocks have the same block name, and the members of the
   // block match exactly in name, type, qualification, and declaration order.
   //
   // - For the purposes of shader interface matching, the gl_PointSize
   //   member of the intrinsically declared gl_PerVertex shader interface
   //   block is ignored.
   // - Output blocks that do not match in name, but have a location and match
   //   in every other way listed above may be considered to match by some
   //   implementations, but not all - so this behaviour should not be relied
   //   upon.

   // An output variable is considered to match an input variable in the subsequent
   // shader if:
   //
   // - the two variables match in name, type, and qualification; or
   // - the two variables are declared with the same location qualifier and
   //   match in type and qualification.

   if (namesMatch || locationsMatch)
   {
       std::string mismatchedStructFieldName;
       LinkMismatchError linkError =
           LinkValidateVaryings(output, input, frontShaderVersion, frontShaderType, backShaderType,
                                isSeparable, &mismatchedStructFieldName);
       if (linkError != LinkMismatchError::NO_MISMATCH)
       {
           LogLinkMismatch(infoLog, input.name, "varying", linkError, mismatchedStructFieldName,
                           frontShaderType, backShaderType);
           return false;
       }

       return true;
   }

   return false;
}

const char *GetInterfaceBlockTypeString(sh::BlockType blockType)
{
   switch (blockType)
   {
       case sh::BlockType::BLOCK_UNIFORM:
           return "uniform block";
       case sh::BlockType::BLOCK_BUFFER:
           return "shader storage block";
       default:
           UNREACHABLE();
           return "";
   }
}

std::string GetInterfaceBlockLimitName(ShaderType shaderType, sh::BlockType blockType)
{
   std::ostringstream stream;
   stream << "GL_MAX_" << GetShaderTypeString(shaderType) << "_";

   switch (blockType)
   {
       case sh::BlockType::BLOCK_UNIFORM:
           stream << "UNIFORM_BUFFERS";
           break;
       case sh::BlockType::BLOCK_BUFFER:
           stream << "SHADER_STORAGE_BLOCKS";
           break;
       default:
           UNREACHABLE();
           return "";
   }

   if (shaderType == ShaderType::Geometry)
   {
       stream << "_EXT";
   }

   return stream.str();
}

void LogInterfaceBlocksExceedLimit(InfoLog &infoLog,
                                  ShaderType shaderType,
                                  sh::BlockType blockType,
                                  GLuint limit)
{
   infoLog << GetShaderTypeString(shaderType) << " shader "
           << GetInterfaceBlockTypeString(blockType) << " count exceeds "
           << GetInterfaceBlockLimitName(shaderType, blockType) << " (" << limit << ")";
}

bool ValidateInterfaceBlocksCount(GLuint maxInterfaceBlocks,
                                 const std::vector<sh::InterfaceBlock> &interfaceBlocks,
                                 ShaderType shaderType,
                                 sh::BlockType blockType,
                                 GLuint *combinedInterfaceBlocksCount,
                                 InfoLog &infoLog)
{
   GLuint blockCount = 0;
   for (const sh::InterfaceBlock &block : interfaceBlocks)
   {
       if (IsActiveInterfaceBlock(block))
       {
           blockCount += std::max(block.arraySize, 1u);
           if (blockCount > maxInterfaceBlocks)
           {
               LogInterfaceBlocksExceedLimit(infoLog, shaderType, blockType, maxInterfaceBlocks);
               return false;
           }
       }
   }

   // [OpenGL ES 3.1] Chapter 7.6.2 Page 105:
   // If a uniform block is used by multiple shader stages, each such use counts separately
   // against this combined limit.
   // [OpenGL ES 3.1] Chapter 7.8 Page 111:
   // If a shader storage block in a program is referenced by multiple shaders, each such
   // reference counts separately against this combined limit.
   if (combinedInterfaceBlocksCount)
   {
       *combinedInterfaceBlocksCount += blockCount;
   }

   return true;
}
}  // anonymous namespace

UniformLinker::UniformLinker(const ShaderBitSet &activeShaderStages,
                            const ShaderMap<std::vector<sh::ShaderVariable>> &shaderUniforms)
   : mActiveShaderStages(activeShaderStages), mShaderUniforms(shaderUniforms)
{}

UniformLinker::~UniformLinker() = default;

void UniformLinker::getResults(std::vector<LinkedUniform> *uniforms,
                              std::vector<UnusedUniform> *unusedUniformsOutOrNull,
                              std::vector<VariableLocation> *uniformLocationsOutOrNull)
{
   uniforms->swap(mUniforms);

   if (unusedUniformsOutOrNull)
   {
       unusedUniformsOutOrNull->swap(mUnusedUniforms);
   }

   if (uniformLocationsOutOrNull)
   {
       uniformLocationsOutOrNull->swap(mUniformLocations);
   }
}

bool UniformLinker::link(const Caps &caps,
                        InfoLog &infoLog,
                        const ProgramAliasedBindings &uniformLocationBindings)
{
   if (mActiveShaderStages[ShaderType::Vertex] && mActiveShaderStages[ShaderType::Fragment])
   {
       if (!validateGraphicsUniforms(infoLog))
       {
           return false;
       }
   }

   // Flatten the uniforms list (nested fields) into a simple list (no nesting).
   // Also check the maximum uniform vector and sampler counts.
   if (!flattenUniformsAndCheckCaps(caps, infoLog))
   {
       return false;
   }

   if (!checkMaxCombinedAtomicCounters(caps, infoLog))
   {
       return false;
   }

   if (!indexUniforms(infoLog, uniformLocationBindings))
   {
       return false;
   }

   return true;
}

bool UniformLinker::validateGraphicsUniforms(InfoLog &infoLog) const
{
   // Check that uniforms defined in the graphics shaders are identical
   std::map<std::string, ShaderUniform> linkedUniforms;

   for (const ShaderType shaderType : mActiveShaderStages)
   {
       if (shaderType == ShaderType::Vertex)
       {
           for (const sh::ShaderVariable &vertexUniform : mShaderUniforms[ShaderType::Vertex])
           {
               linkedUniforms[vertexUniform.name] =
                   std::make_pair(ShaderType::Vertex, &vertexUniform);
           }
       }
       else
       {
           bool isLastShader = (shaderType == ShaderType::Fragment);
           if (!validateGraphicsUniformsPerShader(shaderType, !isLastShader, &linkedUniforms,
                                                  infoLog))
           {
               return false;
           }
       }
   }

   return true;
}

bool UniformLinker::validateGraphicsUniformsPerShader(
   ShaderType shaderToLink,
   bool extendLinkedUniforms,
   std::map<std::string, ShaderUniform> *linkedUniforms,
   InfoLog &infoLog) const
{
   ASSERT(mActiveShaderStages[shaderToLink] && linkedUniforms);

   for (const sh::ShaderVariable &uniform : mShaderUniforms[shaderToLink])
   {
       const auto &entry = linkedUniforms->find(uniform.name);
       if (entry != linkedUniforms->end())
       {
           const sh::ShaderVariable &linkedUniform = *(entry->second.second);
           std::string mismatchedStructFieldName;
           LinkMismatchError linkError =
               LinkValidateUniforms(uniform, linkedUniform, &mismatchedStructFieldName);
           if (linkError != LinkMismatchError::NO_MISMATCH)
           {
               LogLinkMismatch(infoLog, uniform.name, "uniform", linkError,
                               mismatchedStructFieldName, entry->second.first, shaderToLink);
               return false;
           }
       }
       else if (extendLinkedUniforms)
       {
           (*linkedUniforms)[uniform.name] = std::make_pair(shaderToLink, &uniform);
       }
   }

   return true;
}

bool UniformLinker::indexUniforms(InfoLog &infoLog,
                                 const ProgramAliasedBindings &uniformLocationBindings)
{
   // Locations which have been allocated for an unused uniform.
   std::set<GLuint> ignoredLocations;

   int maxUniformLocation = -1;

   // Gather uniform locations that have been set either using the bindUniformLocationCHROMIUM API
   // or by using a location layout qualifier and check conflicts between them.
   if (!gatherUniformLocationsAndCheckConflicts(infoLog, uniformLocationBindings,
                                                &ignoredLocations, &maxUniformLocation))
   {
       return false;
   }

   // Conflicts have been checked, now we can prune non-statically used uniforms. Code further down
   // the line relies on only having statically used uniforms in mUniforms.
   pruneUnusedUniforms();

   // Gather uniforms that have their location pre-set and uniforms that don't yet have a location.
   std::vector<VariableLocation> unlocatedUniforms;
   std::map<GLuint, VariableLocation> preLocatedUniforms;

   for (size_t uniformIndex = 0; uniformIndex < mUniforms.size(); uniformIndex++)
   {
       const LinkedUniform &uniform = mUniforms[uniformIndex];

       if ((uniform.isBuiltIn() && !uniform.isEmulatedBuiltIn()) ||
           IsAtomicCounterType(uniform.type) || uniform.isFragmentInOut)
       {
           continue;
       }

       int preSetLocation = uniformLocationBindings.getBinding(uniform);
       int shaderLocation = uniform.location;

       if (shaderLocation != -1)
       {
           preSetLocation = shaderLocation;
       }

       unsigned int elementCount = uniform.getBasicTypeElementCount();
       for (unsigned int arrayIndex = 0; arrayIndex < elementCount; arrayIndex++)
       {
           VariableLocation location(arrayIndex, static_cast<unsigned int>(uniformIndex));

           if ((arrayIndex == 0 && preSetLocation != -1) || shaderLocation != -1)
           {
               int elementLocation                 = preSetLocation + arrayIndex;
               preLocatedUniforms[elementLocation] = location;
           }
           else
           {
               unlocatedUniforms.push_back(location);
           }
       }
   }

   // Make enough space for all uniforms, with pre-set locations or not.
   mUniformLocations.resize(
       std::max(unlocatedUniforms.size() + preLocatedUniforms.size() + ignoredLocations.size(),
                static_cast<size_t>(maxUniformLocation + 1)));

   // Assign uniforms with pre-set locations
   for (const auto &uniform : preLocatedUniforms)
   {
       mUniformLocations[uniform.first] = uniform.second;
   }

   // Assign ignored uniforms
   for (const auto &ignoredLocation : ignoredLocations)
   {
       mUniformLocations[ignoredLocation].markIgnored();
   }

   // Automatically assign locations for the rest of the uniforms
   size_t nextUniformLocation = 0;
   for (const auto &unlocatedUniform : unlocatedUniforms)
   {
       while (mUniformLocations[nextUniformLocation].used() ||
              mUniformLocations[nextUniformLocation].ignored)
       {
           nextUniformLocation++;
       }

       ASSERT(nextUniformLocation < mUniformLocations.size());
       mUniformLocations[nextUniformLocation] = unlocatedUniform;
       nextUniformLocation++;
   }

   return true;
}

bool UniformLinker::gatherUniformLocationsAndCheckConflicts(
   InfoLog &infoLog,
   const ProgramAliasedBindings &uniformLocationBindings,
   std::set<GLuint> *ignoredLocations,
   int *maxUniformLocation)
{
   // All the locations where another uniform can't be located.
   std::set<GLuint> reservedLocations;

   for (const LinkedUniform &uniform : mUniforms)
   {
       if ((uniform.isBuiltIn() && !uniform.isEmulatedBuiltIn()) || uniform.isFragmentInOut)
       {
           // The uniform of the fragment inout is not a normal uniform type. So, in the case of
           // the fragment inout, this routine should be skipped.
           continue;
       }

       int apiBoundLocation = uniformLocationBindings.getBinding(uniform);
       int shaderLocation   = uniform.location;

       if (shaderLocation != -1)
       {
           unsigned int elementCount = uniform.getBasicTypeElementCount();

           for (unsigned int arrayIndex = 0; arrayIndex < elementCount; arrayIndex++)
           {
               // GLSL ES 3.10 section 4.4.3
               int elementLocation = shaderLocation + arrayIndex;
               *maxUniformLocation = std::max(*maxUniformLocation, elementLocation);
               if (reservedLocations.find(elementLocation) != reservedLocations.end())
               {
                   infoLog << "Multiple uniforms bound to location " << elementLocation << ".";
                   return false;
               }
               reservedLocations.insert(elementLocation);
               if (!uniform.active)
               {
                   ignoredLocations->insert(elementLocation);
               }
           }
       }
       else if (apiBoundLocation != -1 && uniform.staticUse)
       {
           // Only the first location is reserved even if the uniform is an array.
           *maxUniformLocation = std::max(*maxUniformLocation, apiBoundLocation);
           if (reservedLocations.find(apiBoundLocation) != reservedLocations.end())
           {
               infoLog << "Multiple uniforms bound to location " << apiBoundLocation << ".";
               return false;
           }
           reservedLocations.insert(apiBoundLocation);
           if (!uniform.active)
           {
               ignoredLocations->insert(apiBoundLocation);
           }
       }
   }

   // Record the uniform locations that were bound using the API for uniforms that were not found
   // from the shader. Other uniforms should not be assigned to those locations.
   for (const auto &locationBinding : uniformLocationBindings)
   {
       GLuint location = locationBinding.second.location;
       if (reservedLocations.find(location) == reservedLocations.end())
       {
           ignoredLocations->insert(location);
           *maxUniformLocation = std::max(*maxUniformLocation, static_cast<int>(location));
       }
   }

   return true;
}

void UniformLinker::pruneUnusedUniforms()
{
   auto uniformIter = mUniforms.begin();
   while (uniformIter != mUniforms.end())
   {
       if (uniformIter->active)
       {
           ++uniformIter;
       }
       else
       {
           mUnusedUniforms.emplace_back(uniformIter->name, uniformIter->isSampler(),
                                        uniformIter->isImage(), uniformIter->isAtomicCounter(),
                                        uniformIter->isFragmentInOut);
           uniformIter = mUniforms.erase(uniformIter);
       }
   }
}

bool UniformLinker::flattenUniformsAndCheckCapsForShader(
   ShaderType shaderType,
   const Caps &caps,
   std::vector<LinkedUniform> &samplerUniforms,
   std::vector<LinkedUniform> &imageUniforms,
   std::vector<LinkedUniform> &atomicCounterUniforms,
   std::vector<LinkedUniform> &inputAttachmentUniforms,
   std::vector<UnusedUniform> &unusedUniforms,
   InfoLog &infoLog)
{
   ShaderUniformCount shaderUniformCount;
   for (const sh::ShaderVariable &uniform : mShaderUniforms[shaderType])
   {
       FlattenUniformVisitor flattener(shaderType, uniform, &mUniforms, &samplerUniforms,
                                       &imageUniforms, &atomicCounterUniforms,
                                       &inputAttachmentUniforms, &unusedUniforms);
       sh::TraverseShaderVariable(uniform, false, &flattener);

       if (uniform.active)
       {
           shaderUniformCount += flattener.getCounts();
       }
       else
       {
           unusedUniforms.emplace_back(uniform.name, IsSamplerType(uniform.type),
                                       IsImageType(uniform.type),
                                       IsAtomicCounterType(uniform.type), uniform.isFragmentInOut);
       }
   }

   // This code does not do fine-grained component counting.
   GLuint maxUniformVectorsCount = GetMaximumShaderUniformVectors(shaderType, caps);
   if (shaderUniformCount.vectorCount > maxUniformVectorsCount)
   {
       GLuint maxUniforms = 0u;

       // See comments in GetUniformResourceLimitName()
       if (shaderType == ShaderType::Vertex || shaderType == ShaderType::Fragment)
       {
           maxUniforms = maxUniformVectorsCount;
       }
       else
       {
           maxUniforms = maxUniformVectorsCount * 4;
       }

       LogUniformsExceedLimit(shaderType, UniformType::Variable, maxUniforms, infoLog);
       return false;
   }

   if (shaderUniformCount.samplerCount >
       static_cast<GLuint>(caps.maxShaderTextureImageUnits[shaderType]))
   {
       LogUniformsExceedLimit(shaderType, UniformType::Sampler,
                              caps.maxShaderTextureImageUnits[shaderType], infoLog);
       return false;
   }

   if (shaderUniformCount.imageCount >
       static_cast<GLuint>(caps.maxShaderImageUniforms[shaderType]))
   {
       LogUniformsExceedLimit(shaderType, UniformType::Image,
                              caps.maxShaderImageUniforms[shaderType], infoLog);
       return false;
   }

   if (shaderUniformCount.atomicCounterCount >
       static_cast<GLuint>(caps.maxShaderAtomicCounters[shaderType]))
   {
       LogUniformsExceedLimit(shaderType, UniformType::AtomicCounter,
                              caps.maxShaderAtomicCounters[shaderType], infoLog);
       return false;
   }

   return true;
}

bool UniformLinker::flattenUniformsAndCheckCaps(const Caps &caps, InfoLog &infoLog)
{
   std::vector<LinkedUniform> samplerUniforms;
   std::vector<LinkedUniform> imageUniforms;
   std::vector<LinkedUniform> atomicCounterUniforms;
   std::vector<LinkedUniform> inputAttachmentUniforms;
   std::vector<UnusedUniform> unusedUniforms;

   for (const ShaderType shaderType : mActiveShaderStages)
   {
       if (!flattenUniformsAndCheckCapsForShader(shaderType, caps, samplerUniforms, imageUniforms,
                                                 atomicCounterUniforms, inputAttachmentUniforms,
                                                 unusedUniforms, infoLog))
       {
           return false;
       }
   }

   mUniforms.insert(mUniforms.end(), samplerUniforms.begin(), samplerUniforms.end());
   mUniforms.insert(mUniforms.end(), imageUniforms.begin(), imageUniforms.end());
   mUniforms.insert(mUniforms.end(), atomicCounterUniforms.begin(), atomicCounterUniforms.end());
   mUniforms.insert(mUniforms.end(), inputAttachmentUniforms.begin(),
                    inputAttachmentUniforms.end());
   mUnusedUniforms.insert(mUnusedUniforms.end(), unusedUniforms.begin(), unusedUniforms.end());
   return true;
}

bool UniformLinker::checkMaxCombinedAtomicCounters(const Caps &caps, InfoLog &infoLog)
{
   unsigned int atomicCounterCount = 0;
   for (const auto &uniform : mUniforms)
   {
       if (IsAtomicCounterType(uniform.type) && uniform.active)
       {
           atomicCounterCount += uniform.getBasicTypeElementCount();
           if (atomicCounterCount > static_cast<GLuint>(caps.maxCombinedAtomicCounters))
           {
               infoLog << "atomic counter count exceeds MAX_COMBINED_ATOMIC_COUNTERS"
                       << caps.maxCombinedAtomicCounters << ").";
               return false;
           }
       }
   }
   return true;
}

// InterfaceBlockLinker implementation.
InterfaceBlockLinker::InterfaceBlockLinker() = default;

InterfaceBlockLinker::~InterfaceBlockLinker() = default;

void InterfaceBlockLinker::init(std::vector<InterfaceBlock> *blocksOut,
                               std::vector<std::string> *unusedInterfaceBlocksOut)
{
   mBlocksOut                = blocksOut;
   mUnusedInterfaceBlocksOut = unusedInterfaceBlocksOut;
}

void InterfaceBlockLinker::addShaderBlocks(ShaderType shaderType,
                                          const std::vector<sh::InterfaceBlock> *blocks)
{
   mShaderBlocks[shaderType] = blocks;
}

void InterfaceBlockLinker::linkBlocks(const GetBlockSizeFunc &getBlockSize,
                                     const GetBlockMemberInfoFunc &getMemberInfo) const
{
   ASSERT(mBlocksOut->empty());

   std::set<std::string> visitedList;

   for (const ShaderType shaderType : AllShaderTypes())
   {
       if (!mShaderBlocks[shaderType])
       {
           continue;
       }

       for (const sh::InterfaceBlock &block : *mShaderBlocks[shaderType])
       {
           if (!IsActiveInterfaceBlock(block))
           {
               mUnusedInterfaceBlocksOut->push_back(block.name);
               continue;
           }

           if (visitedList.count(block.name) == 0)
           {
               defineInterfaceBlock(getBlockSize, getMemberInfo, block, shaderType);
               visitedList.insert(block.name);
               continue;
           }

           if (!block.active)
           {
               mUnusedInterfaceBlocksOut->push_back(block.name);
               continue;
           }

           for (InterfaceBlock &priorBlock : *mBlocksOut)
           {
               if (block.name == priorBlock.name)
               {
                   priorBlock.setActive(shaderType, true);

                   std::unique_ptr<sh::ShaderVariableVisitor> visitor(
                       getVisitor(getMemberInfo, block.fieldPrefix(), block.fieldMappedPrefix(),
                                  shaderType, -1));

                   sh::TraverseShaderVariables(block.fields, false, visitor.get());
               }
           }
       }
   }
}

void InterfaceBlockLinker::defineInterfaceBlock(const GetBlockSizeFunc &getBlockSize,
                                               const GetBlockMemberInfoFunc &getMemberInfo,
                                               const sh::InterfaceBlock &interfaceBlock,
                                               ShaderType shaderType) const
{
   size_t blockSize = 0;
   std::vector<unsigned int> blockIndexes;

   int blockIndex = static_cast<int>(mBlocksOut->size());
   // Track the first and last block member index to determine the range of active block members in
   // the block.
   size_t firstBlockMemberIndex = getCurrentBlockMemberIndex();

   std::unique_ptr<sh::ShaderVariableVisitor> visitor(
       getVisitor(getMemberInfo, interfaceBlock.fieldPrefix(), interfaceBlock.fieldMappedPrefix(),
                  shaderType, blockIndex));
   sh::TraverseShaderVariables(interfaceBlock.fields, false, visitor.get());

   size_t lastBlockMemberIndex = getCurrentBlockMemberIndex();

   for (size_t blockMemberIndex = firstBlockMemberIndex; blockMemberIndex < lastBlockMemberIndex;
        ++blockMemberIndex)
   {
       blockIndexes.push_back(static_cast<unsigned int>(blockMemberIndex));
   }

   unsigned int firstFieldArraySize = interfaceBlock.fields[0].getArraySizeProduct();

   for (unsigned int arrayElement = 0; arrayElement < interfaceBlock.elementCount();
        ++arrayElement)
   {
       std::string blockArrayName       = interfaceBlock.name;
       std::string blockMappedArrayName = interfaceBlock.mappedName;
       if (interfaceBlock.isArray())
       {
           blockArrayName += ArrayString(arrayElement);
           blockMappedArrayName += ArrayString(arrayElement);
       }

       // Don't define this block at all if it's not active in the implementation.
       if (!getBlockSize(blockArrayName, blockMappedArrayName, &blockSize))
       {
           continue;
       }

       // ESSL 3.10 section 4.4.4 page 58:
       // Any uniform or shader storage block declared without a binding qualifier is initially
       // assigned to block binding point zero.
       int blockBinding =
           (interfaceBlock.binding == -1 ? 0 : interfaceBlock.binding + arrayElement);
       InterfaceBlock block(interfaceBlock.name, interfaceBlock.mappedName,
                            interfaceBlock.isArray(), arrayElement, firstFieldArraySize,
                            blockBinding);
       block.memberIndexes = blockIndexes;
       block.setActive(shaderType, interfaceBlock.active);

       // Since all block elements in an array share the same active interface blocks, they
       // will all be active once any block member is used. So, since interfaceBlock.name[0]
       // was active, here we will add every block element in the array.
       block.dataSize = static_cast<unsigned int>(blockSize);
       mBlocksOut->push_back(block);
   }
}

// UniformBlockLinker implementation.
UniformBlockLinker::UniformBlockLinker() = default;

UniformBlockLinker::~UniformBlockLinker() {}

void UniformBlockLinker::init(std::vector<InterfaceBlock> *blocksOut,
                             std::vector<LinkedUniform> *uniformsOut,
                             std::vector<std::string> *unusedInterfaceBlocksOut)
{
   InterfaceBlockLinker::init(blocksOut, unusedInterfaceBlocksOut);
   mUniformsOut = uniformsOut;
}

size_t UniformBlockLinker::getCurrentBlockMemberIndex() const
{
   return mUniformsOut->size();
}

sh::ShaderVariableVisitor *UniformBlockLinker::getVisitor(
   const GetBlockMemberInfoFunc &getMemberInfo,
   const std::string &namePrefix,
   const std::string &mappedNamePrefix,
   ShaderType shaderType,
   int blockIndex) const
{
   return new UniformBlockEncodingVisitor(getMemberInfo, namePrefix, mappedNamePrefix,
                                          mUniformsOut, shaderType, blockIndex);
}

// ShaderStorageBlockLinker implementation.
ShaderStorageBlockLinker::ShaderStorageBlockLinker() = default;

ShaderStorageBlockLinker::~ShaderStorageBlockLinker() = default;

void ShaderStorageBlockLinker::init(std::vector<InterfaceBlock> *blocksOut,
                                   std::vector<BufferVariable> *bufferVariablesOut,
                                   std::vector<std::string> *unusedInterfaceBlocksOut)
{
   InterfaceBlockLinker::init(blocksOut, unusedInterfaceBlocksOut);
   mBufferVariablesOut = bufferVariablesOut;
}

size_t ShaderStorageBlockLinker::getCurrentBlockMemberIndex() const
{
   return mBufferVariablesOut->size();
}

sh::ShaderVariableVisitor *ShaderStorageBlockLinker::getVisitor(
   const GetBlockMemberInfoFunc &getMemberInfo,
   const std::string &namePrefix,
   const std::string &mappedNamePrefix,
   ShaderType shaderType,
   int blockIndex) const
{
   return new ShaderStorageBlockVisitor(getMemberInfo, namePrefix, mappedNamePrefix,
                                        mBufferVariablesOut, shaderType, blockIndex);
}

// AtomicCounterBufferLinker implementation.
AtomicCounterBufferLinker::AtomicCounterBufferLinker() = default;

AtomicCounterBufferLinker::~AtomicCounterBufferLinker() = default;

void AtomicCounterBufferLinker::init(std::vector<AtomicCounterBuffer> *atomicCounterBuffersOut)
{
   mAtomicCounterBuffersOut = atomicCounterBuffersOut;
}

void AtomicCounterBufferLinker::link(const std::map<int, unsigned int> &sizeMap) const
{
   for (auto &atomicCounterBuffer : *mAtomicCounterBuffersOut)
   {
       auto bufferSize = sizeMap.find(atomicCounterBuffer.binding);
       ASSERT(bufferSize != sizeMap.end());
       atomicCounterBuffer.dataSize = bufferSize->second;
   }
}

ProgramLinkedResources::ProgramLinkedResources() = default;

ProgramLinkedResources::~ProgramLinkedResources() = default;

LinkingVariables::LinkingVariables(const Context *context, const ProgramState &state)
{
   for (ShaderType shaderType : kAllGraphicsShaderTypes)
   {
       Shader *shader = state.getAttachedShader(shaderType);
       if (shader)
       {
           outputVaryings[shaderType] = shader->getOutputVaryings(context);
           inputVaryings[shaderType]  = shader->getInputVaryings(context);
           uniforms[shaderType]       = shader->getUniforms(context);
           uniformBlocks[shaderType]  = shader->getUniformBlocks(context);
           isShaderStageUsedBitset.set(shaderType);
       }
   }
}

LinkingVariables::LinkingVariables(const ProgramPipelineState &state)
{
   for (ShaderType shaderType : state.getExecutable().getLinkedShaderStages())
   {
       const Program *program = state.getShaderProgram(shaderType);
       ASSERT(program);
       outputVaryings[shaderType] = program->getExecutable().getLinkedOutputVaryings(shaderType);
       inputVaryings[shaderType]  = program->getExecutable().getLinkedInputVaryings(shaderType);
       uniforms[shaderType] = program->getState().getExecutable().getLinkedUniforms(shaderType);
       uniformBlocks[shaderType] =
           program->getState().getExecutable().getLinkedUniformBlocks(shaderType);
       isShaderStageUsedBitset.set(shaderType);
   }
}

LinkingVariables::~LinkingVariables() = default;

void ProgramLinkedResources::init(std::vector<InterfaceBlock> *uniformBlocksOut,
                                 std::vector<LinkedUniform> *uniformsOut,
                                 std::vector<InterfaceBlock> *shaderStorageBlocksOut,
                                 std::vector<BufferVariable> *bufferVariablesOut,
                                 std::vector<AtomicCounterBuffer> *atomicCounterBuffersOut)
{
   uniformBlockLinker.init(uniformBlocksOut, uniformsOut, &unusedInterfaceBlocks);
   shaderStorageBlockLinker.init(shaderStorageBlocksOut, bufferVariablesOut,
                                 &unusedInterfaceBlocks);
   atomicCounterBufferLinker.init(atomicCounterBuffersOut);
}

void ProgramLinkedResourcesLinker::linkResources(const Context *context,
                                                const ProgramState &programState,
                                                const ProgramLinkedResources &resources) const
{
   // Gather uniform interface block info.
   InterfaceBlockInfo uniformBlockInfo(mCustomEncoderFactory);
   for (const ShaderType shaderType : AllShaderTypes())
   {
       Shader *shader = programState.getAttachedShader(shaderType);
       if (shader)
       {
           uniformBlockInfo.getShaderBlockInfo(shader->getUniformBlocks(context));
       }
   }

   auto getUniformBlockSize = [&uniformBlockInfo](const std::string &name,
                                                  const std::string &mappedName, size_t *sizeOut) {
       return uniformBlockInfo.getBlockSize(name, mappedName, sizeOut);
   };

   auto getUniformBlockMemberInfo = [&uniformBlockInfo](const std::string &name,
                                                        const std::string &mappedName,
                                                        sh::BlockMemberInfo *infoOut) {
       return uniformBlockInfo.getBlockMemberInfo(name, mappedName, infoOut);
   };

   // Link uniform interface blocks.
   resources.uniformBlockLinker.linkBlocks(getUniformBlockSize, getUniformBlockMemberInfo);

   // Gather storage buffer interface block info.
   InterfaceBlockInfo shaderStorageBlockInfo(mCustomEncoderFactory);
   for (const ShaderType shaderType : AllShaderTypes())
   {
       Shader *shader = programState.getAttachedShader(shaderType);
       if (shader)
       {
           shaderStorageBlockInfo.getShaderBlockInfo(shader->getShaderStorageBlocks(context));
       }
   }
   auto getShaderStorageBlockSize = [&shaderStorageBlockInfo](const std::string &name,
                                                              const std::string &mappedName,
                                                              size_t *sizeOut) {
       return shaderStorageBlockInfo.getBlockSize(name, mappedName, sizeOut);
   };

   auto getShaderStorageBlockMemberInfo = [&shaderStorageBlockInfo](const std::string &name,
                                                                    const std::string &mappedName,
                                                                    sh::BlockMemberInfo *infoOut) {
       return shaderStorageBlockInfo.getBlockMemberInfo(name, mappedName, infoOut);
   };

   // Link storage buffer interface blocks.
   resources.shaderStorageBlockLinker.linkBlocks(getShaderStorageBlockSize,
                                                 getShaderStorageBlockMemberInfo);

   // Gather and link atomic counter buffer interface blocks.
   std::map<int, unsigned int> sizeMap;
   getAtomicCounterBufferSizeMap(programState, sizeMap);
   resources.atomicCounterBufferLinker.link(sizeMap);
}

void ProgramLinkedResourcesLinker::getAtomicCounterBufferSizeMap(
   const ProgramState &programState,
   std::map<int, unsigned int> &sizeMapOut) const
{
   for (unsigned int index : programState.getAtomicCounterUniformRange())
   {
       const LinkedUniform &glUniform = programState.getUniforms()[index];

       auto &bufferDataSize = sizeMapOut[glUniform.binding];

       // Calculate the size of the buffer by finding the end of the last uniform with the same
       // binding. The end of the uniform is calculated by finding the initial offset of the
       // uniform and adding size of the uniform. For arrays, the size is the number of elements
       // times the element size (should always by 4 for atomic_units).
       unsigned dataOffset =
           glUniform.offset + static_cast<unsigned int>(glUniform.getBasicTypeElementCount() *
                                                        glUniform.getElementSize());
       if (dataOffset > bufferDataSize)
       {
           bufferDataSize = dataOffset;
       }
   }
}

bool LinkValidateProgramGlobalNames(InfoLog &infoLog,
                                   const ProgramExecutable &executable,
                                   const LinkingVariables &linkingVariables)
{
   angle::HashMap<std::string, const sh::ShaderVariable *> uniformMap;
   using BlockAndFieldPair = std::pair<const sh::InterfaceBlock *, const sh::ShaderVariable *>;
   angle::HashMap<std::string, std::vector<BlockAndFieldPair>> uniformBlockFieldMap;

   for (ShaderType shaderType : kAllGraphicsShaderTypes)
   {
       if (!linkingVariables.isShaderStageUsedBitset[shaderType])
       {
           continue;
       }

       // Build a map of Uniforms
       const std::vector<sh::ShaderVariable> &uniforms = linkingVariables.uniforms[shaderType];
       for (const auto &uniform : uniforms)
       {
           uniformMap[uniform.name] = &uniform;
       }

       // Build a map of Uniform Blocks
       // This will also detect any field name conflicts between Uniform Blocks without instance
       // names
       const std::vector<sh::InterfaceBlock> &uniformBlocks =
           linkingVariables.uniformBlocks[shaderType];

       for (const auto &uniformBlock : uniformBlocks)
       {
           // Only uniform blocks without an instance name can create a conflict with their field
           // names
           if (!uniformBlock.instanceName.empty())
           {
               continue;
           }

           for (const auto &field : uniformBlock.fields)
           {
               if (!uniformBlockFieldMap.count(field.name))
               {
                   // First time we've seen this uniform block field name, so add the
                   // (Uniform Block, Field) pair immediately since there can't be a conflict yet
                   BlockAndFieldPair blockAndFieldPair(&uniformBlock, &field);
                   std::vector<BlockAndFieldPair> newUniformBlockList;
                   newUniformBlockList.push_back(blockAndFieldPair);
                   uniformBlockFieldMap[field.name] = newUniformBlockList;
                   continue;
               }

               // We've seen this name before.
               // We need to check each of the uniform blocks that contain a field with this name
               // to see if there's a conflict or not.
               std::vector<BlockAndFieldPair> prevBlockFieldPairs =
                   uniformBlockFieldMap[field.name];
               for (const auto &prevBlockFieldPair : prevBlockFieldPairs)
               {
                   const sh::InterfaceBlock *prevUniformBlock      = prevBlockFieldPair.first;
                   const sh::ShaderVariable *prevUniformBlockField = prevBlockFieldPair.second;

                   if (uniformBlock.isSameInterfaceBlockAtLinkTime(*prevUniformBlock))
                   {
                       // The same uniform block should, by definition, contain the same field name
                       continue;
                   }

                   // The uniform blocks don't match, so check if the necessary field properties
                   // also match
                   if ((field.name == prevUniformBlockField->name) &&
                       (field.type == prevUniformBlockField->type) &&
                       (field.precision == prevUniformBlockField->precision))
                   {
                       infoLog << "Name conflicts between uniform block field names: "
                               << field.name;
                       return false;
                   }
               }

               // No conflict, so record this pair
               BlockAndFieldPair blockAndFieldPair(&uniformBlock, &field);
               uniformBlockFieldMap[field.name].push_back(blockAndFieldPair);
           }
       }
   }

   // Validate no uniform names conflict with attribute names
   if (linkingVariables.isShaderStageUsedBitset[ShaderType::Vertex])
   {
       // ESSL 3.00.6 section 4.3.5:
       // If a uniform variable name is declared in one stage (e.g., a vertex shader)
       // but not in another (e.g., a fragment shader), then that name is still
       // available in the other stage for a different use.
       std::unordered_set<std::string> uniforms;
       for (const sh::ShaderVariable &uniform : linkingVariables.uniforms[ShaderType::Vertex])
       {
           uniforms.insert(uniform.name);
       }
       for (const auto &attrib : executable.getProgramInputs())
       {
           if (uniforms.count(attrib.name))
           {
               infoLog << "Name conflicts between a uniform and an attribute: " << attrib.name;
               return false;
           }
       }
   }

   // Validate no Uniform Block fields conflict with other Uniforms
   for (const auto &uniformBlockField : uniformBlockFieldMap)
   {
       const std::string &fieldName = uniformBlockField.first;
       if (uniformMap.count(fieldName))
       {
           infoLog << "Name conflicts between a uniform and a uniform block field: " << fieldName;
           return false;
       }
   }

   return true;
}

// [OpenGL ES 3.2] Chapter 7.4.1 "Shader Interface Matching"
bool LinkValidateShaderInterfaceMatching(const std::vector<sh::ShaderVariable> &outputVaryings,
                                        const std::vector<sh::ShaderVariable> &inputVaryings,
                                        ShaderType frontShaderType,
                                        ShaderType backShaderType,
                                        int frontShaderVersion,
                                        int backShaderVersion,
                                        bool isSeparable,
                                        gl::InfoLog &infoLog)
{
   ASSERT(frontShaderVersion == backShaderVersion);

   std::vector<const sh::ShaderVariable *> filteredInputVaryings;
   std::vector<const sh::ShaderVariable *> filteredOutputVaryings;

   GetFilteredVaryings(inputVaryings, &filteredInputVaryings);
   GetFilteredVaryings(outputVaryings, &filteredOutputVaryings);

   // Separable programs require the number of inputs and outputs match
   if (isSeparable && filteredInputVaryings.size() < filteredOutputVaryings.size())
   {
       infoLog << GetShaderTypeString(backShaderType)
               << " does not consume all varyings generated by "
               << GetShaderTypeString(frontShaderType);
       return false;
   }
   if (isSeparable && filteredInputVaryings.size() > filteredOutputVaryings.size())
   {
       infoLog << GetShaderTypeString(frontShaderType)
               << " does not generate all varyings consumed by "
               << GetShaderTypeString(backShaderType);
       return false;
   }

   // All inputs must match all outputs
   for (const sh::ShaderVariable *input : filteredInputVaryings)
   {
       bool match = false;
       for (const sh::ShaderVariable *output : filteredOutputVaryings)
       {
           if (DoShaderVariablesMatch(frontShaderVersion, frontShaderType, backShaderType, *input,
                                      *output, isSeparable, infoLog))
           {
               match = true;
               break;
           }
       }

       // We permit unmatched, unreferenced varyings. Note that this specifically depends on
       // whether the input is statically used - a statically used input should fail this test even
       // if it is not active. GLSL ES 3.00.6 section 4.3.10.
       if (!match && input->staticUse)
       {
           const std::string &name =
               input->isShaderIOBlock ? input->structOrBlockName : input->name;
           infoLog << GetShaderTypeString(backShaderType) << " varying " << name
                   << " does not match any " << GetShaderTypeString(frontShaderType) << " varying";
           return false;
       }
   }

   return true;
}

LinkMismatchError LinkValidateProgramVariables(const sh::ShaderVariable &variable1,
                                              const sh::ShaderVariable &variable2,
                                              bool validatePrecision,
                                              bool treatVariable1AsNonArray,
                                              bool treatVariable2AsNonArray,
                                              std::string *mismatchedStructOrBlockMemberName)
{
   if (variable1.type != variable2.type)
   {
       return LinkMismatchError::TYPE_MISMATCH;
   }

   bool variable1IsArray = variable1.isArray();
   bool variable2IsArray = variable2.isArray();
   if (treatVariable1AsNonArray)
   {
       ASSERT(variable1IsArray);
       variable1IsArray = false;
   }
   if (treatVariable2AsNonArray)
   {
       ASSERT(variable2IsArray);
       variable2IsArray = false;
   }
   // TODO(anglebug.com/5557): Investigate interactions with arrays-of-arrays.
   if (variable1IsArray != variable2IsArray)
   {
       return LinkMismatchError::ARRAYNESS_MISMATCH;
   }
   if (!treatVariable1AsNonArray && !treatVariable2AsNonArray &&
       variable1.arraySizes != variable2.arraySizes)
   {
       return LinkMismatchError::ARRAY_SIZE_MISMATCH;
   }
   if (validatePrecision && variable1.precision != variable2.precision)
   {
       return LinkMismatchError::PRECISION_MISMATCH;
   }
   if (!variable1.isShaderIOBlock && !variable2.isShaderIOBlock &&
       variable1.structOrBlockName != variable2.structOrBlockName)
   {
       return LinkMismatchError::STRUCT_NAME_MISMATCH;
   }
   if (variable1.imageUnitFormat != variable2.imageUnitFormat)
   {
       return LinkMismatchError::FORMAT_MISMATCH;
   }

   if (variable1.fields.size() != variable2.fields.size())
   {
       return LinkMismatchError::FIELD_NUMBER_MISMATCH;
   }
   const unsigned int numMembers = static_cast<unsigned int>(variable1.fields.size());
   for (unsigned int memberIndex = 0; memberIndex < numMembers; memberIndex++)
   {
       const sh::ShaderVariable &member1 = variable1.fields[memberIndex];
       const sh::ShaderVariable &member2 = variable2.fields[memberIndex];

       if (member1.name != member2.name)
       {
           return LinkMismatchError::FIELD_NAME_MISMATCH;
       }

       if (member1.interpolation != member2.interpolation)
       {
           return LinkMismatchError::INTERPOLATION_TYPE_MISMATCH;
       }

       if (variable1.isShaderIOBlock && variable2.isShaderIOBlock)
       {
           if (member1.location != member2.location)
           {
               return LinkMismatchError::FIELD_LOCATION_MISMATCH;
           }

           if (member1.structOrBlockName != member2.structOrBlockName)
           {
               return LinkMismatchError::FIELD_STRUCT_NAME_MISMATCH;
           }
       }

       LinkMismatchError linkErrorOnField = LinkValidateProgramVariables(
           member1, member2, validatePrecision, false, false, mismatchedStructOrBlockMemberName);
       if (linkErrorOnField != LinkMismatchError::NO_MISMATCH)
       {
           AddProgramVariableParentPrefix(member1.name, mismatchedStructOrBlockMemberName);
           return linkErrorOnField;
       }
   }

   return LinkMismatchError::NO_MISMATCH;
}

void AddProgramVariableParentPrefix(const std::string &parentName, std::string *mismatchedFieldName)
{
   ASSERT(mismatchedFieldName);
   if (mismatchedFieldName->empty())
   {
       *mismatchedFieldName = parentName;
   }
   else
   {
       std::ostringstream stream;
       stream << parentName << "." << *mismatchedFieldName;
       *mismatchedFieldName = stream.str();
   }
}

bool LinkValidateBuiltInVaryingsInvariant(const std::vector<sh::ShaderVariable> &vertexVaryings,
                                         const std::vector<sh::ShaderVariable> &fragmentVaryings,
                                         int vertexShaderVersion,
                                         InfoLog &infoLog)
{
   bool glPositionIsInvariant   = false;
   bool glPointSizeIsInvariant  = false;
   bool glFragCoordIsInvariant  = false;
   bool glPointCoordIsInvariant = false;

   for (const sh::ShaderVariable &varying : vertexVaryings)
   {
       if (!varying.isBuiltIn())
       {
           continue;
       }
       if (varying.name.compare("gl_Position") == 0)
       {
           glPositionIsInvariant = varying.isInvariant;
       }
       else if (varying.name.compare("gl_PointSize") == 0)
       {
           glPointSizeIsInvariant = varying.isInvariant;
       }
   }

   for (const sh::ShaderVariable &varying : fragmentVaryings)
   {
       if (!varying.isBuiltIn())
       {
           continue;
       }
       if (varying.name.compare("gl_FragCoord") == 0)
       {
           glFragCoordIsInvariant = varying.isInvariant;
       }
       else if (varying.name.compare("gl_PointCoord") == 0)
       {
           glPointCoordIsInvariant = varying.isInvariant;
       }
   }

   // There is some ambiguity in ESSL 1.00.17 paragraph 4.6.4 interpretation,
   // for example, https://cvs.khronos.org/bugzilla/show_bug.cgi?id=13842.
   // Not requiring invariance to match is supported by:
   // dEQP, WebGL CTS, Nexus 5X GLES
   if (glFragCoordIsInvariant && !glPositionIsInvariant)
   {
       infoLog << "gl_FragCoord can only be declared invariant if and only if gl_Position is "
                  "declared invariant.";
       return false;
   }
   if (glPointCoordIsInvariant && !glPointSizeIsInvariant)
   {
       infoLog << "gl_PointCoord can only be declared invariant if and only if gl_PointSize is "
                  "declared invariant.";
       return false;
   }

   return true;
}

bool LinkValidateBuiltInVaryings(const std::vector<sh::ShaderVariable> &outputVaryings,
                                const std::vector<sh::ShaderVariable> &inputVaryings,
                                ShaderType outputShaderType,
                                ShaderType inputShaderType,
                                int outputShaderVersion,
                                int inputShaderVersion,
                                InfoLog &infoLog)
{
   ASSERT(outputShaderVersion == inputShaderVersion);

   // Only ESSL 1.0 has restrictions on matching input and output invariance
   if (inputShaderVersion == 100 && outputShaderType == ShaderType::Vertex &&
       inputShaderType == ShaderType::Fragment)
   {
       return LinkValidateBuiltInVaryingsInvariant(outputVaryings, inputVaryings,
                                                   outputShaderVersion, infoLog);
   }

   uint32_t sizeClipDistance = 0;
   uint32_t sizeCullDistance = 0;

   for (const sh::ShaderVariable &varying : outputVaryings)
   {
       if (!varying.isBuiltIn())
       {
           continue;
       }
       if (varying.name.compare("gl_ClipDistance") == 0)
       {
           sizeClipDistance = varying.getOutermostArraySize();
       }
       else if (varying.name.compare("gl_CullDistance") == 0)
       {
           sizeCullDistance = varying.getOutermostArraySize();
       }
   }

   for (const sh::ShaderVariable &varying : inputVaryings)
   {
       if (!varying.isBuiltIn())
       {
           continue;
       }
       if (varying.name.compare("gl_ClipDistance") == 0)
       {
           if (sizeClipDistance != varying.getOutermostArraySize())
           {
               infoLog << "If either shader redeclares the built-in arrays gl_ClipDistance[] the "
                          "array must have the same size in both shaders.";
               return false;
           }
       }
       else if (varying.name.compare("gl_CullDistance") == 0)
       {
           if (sizeCullDistance != varying.getOutermostArraySize())
           {
               infoLog << "If either shader redeclares the built-in arrays gl_CullDistance[] the "
                          "array must have the same size in both shaders.";
               return false;
           }
       }
   }
   return true;
}

void LogAmbiguousFieldLinkMismatch(InfoLog &infoLog,
                                  const std::string &blockName1,
                                  const std::string &blockName2,
                                  const std::string &fieldName,
                                  ShaderType shaderType1,
                                  ShaderType shaderType2)
{
   infoLog << "Ambiguous field '" << fieldName << "' in blocks '" << blockName1 << "' ("
           << GetShaderTypeString(shaderType1) << " shader) and '" << blockName2 << "' ("
           << GetShaderTypeString(shaderType2) << " shader) which don't have instance names.";
}

bool ValidateInstancelessGraphicsInterfaceBlocksPerShader(
   const std::vector<sh::InterfaceBlock> &interfaceBlocks,
   ShaderType shaderType,
   InterfaceBlockMap *instancelessBlocksFields,
   InfoLog &infoLog)
{
   ASSERT(instancelessBlocksFields);

   for (const sh::InterfaceBlock &block : interfaceBlocks)
   {
       if (!block.instanceName.empty())
       {
           continue;
       }

       for (const sh::ShaderVariable &field : block.fields)
       {
           const auto &entry = instancelessBlocksFields->find(field.name);
           if (entry != instancelessBlocksFields->end())
           {
               const sh::InterfaceBlock &linkedBlock = *(entry->second.second);
               if (block.name != linkedBlock.name)
               {
                   LogAmbiguousFieldLinkMismatch(infoLog, block.name, linkedBlock.name, field.name,
                                                 entry->second.first, shaderType);
                   return false;
               }
           }
           else
           {
               (*instancelessBlocksFields)[field.name] = std::make_pair(shaderType, &block);
           }
       }
   }

   return true;
}

LinkMismatchError LinkValidateInterfaceBlockFields(const sh::ShaderVariable &blockField1,
                                                  const sh::ShaderVariable &blockField2,
                                                  bool webglCompatibility,
                                                  std::string *mismatchedBlockFieldName)
{
   if (blockField1.name != blockField2.name)
   {
       return LinkMismatchError::FIELD_NAME_MISMATCH;
   }

   // If webgl, validate precision of UBO fields, otherwise don't.  See Khronos bug 10287.
   LinkMismatchError linkError = LinkValidateProgramVariables(
       blockField1, blockField2, webglCompatibility, false, false, mismatchedBlockFieldName);
   if (linkError != LinkMismatchError::NO_MISMATCH)
   {
       AddProgramVariableParentPrefix(blockField1.name, mismatchedBlockFieldName);
       return linkError;
   }

   if (blockField1.isRowMajorLayout != blockField2.isRowMajorLayout)
   {
       AddProgramVariableParentPrefix(blockField1.name, mismatchedBlockFieldName);
       return LinkMismatchError::MATRIX_PACKING_MISMATCH;
   }

   return LinkMismatchError::NO_MISMATCH;
}

LinkMismatchError AreMatchingInterfaceBlocks(const sh::InterfaceBlock &interfaceBlock1,
                                            const sh::InterfaceBlock &interfaceBlock2,
                                            bool webglCompatibility,
                                            std::string *mismatchedBlockFieldName)
{
   // validate blocks for the same member types
   if (interfaceBlock1.fields.size() != interfaceBlock2.fields.size())
   {
       return LinkMismatchError::FIELD_NUMBER_MISMATCH;
   }
   if (interfaceBlock1.arraySize != interfaceBlock2.arraySize)
   {
       return LinkMismatchError::ARRAY_SIZE_MISMATCH;
   }
   if (interfaceBlock1.layout != interfaceBlock2.layout ||
       interfaceBlock1.binding != interfaceBlock2.binding)
   {
       return LinkMismatchError::LAYOUT_QUALIFIER_MISMATCH;
   }
   if (interfaceBlock1.instanceName.empty() != interfaceBlock2.instanceName.empty())
   {
       return LinkMismatchError::INSTANCE_NAME_MISMATCH;
   }
   const unsigned int numBlockMembers = static_cast<unsigned int>(interfaceBlock1.fields.size());
   for (unsigned int blockMemberIndex = 0; blockMemberIndex < numBlockMembers; blockMemberIndex++)
   {
       const sh::ShaderVariable &member1 = interfaceBlock1.fields[blockMemberIndex];
       const sh::ShaderVariable &member2 = interfaceBlock2.fields[blockMemberIndex];

       LinkMismatchError linkError = LinkValidateInterfaceBlockFields(
           member1, member2, webglCompatibility, mismatchedBlockFieldName);
       if (linkError != LinkMismatchError::NO_MISMATCH)
       {
           return linkError;
       }
   }
   return LinkMismatchError::NO_MISMATCH;
}

void InitializeInterfaceBlockMap(const std::vector<sh::InterfaceBlock> &interfaceBlocks,
                                ShaderType shaderType,
                                InterfaceBlockMap *linkedInterfaceBlocks)
{
   ASSERT(linkedInterfaceBlocks);

   for (const sh::InterfaceBlock &interfaceBlock : interfaceBlocks)
   {
       (*linkedInterfaceBlocks)[interfaceBlock.name] = std::make_pair(shaderType, &interfaceBlock);
   }
}

bool ValidateGraphicsInterfaceBlocksPerShader(
   const std::vector<sh::InterfaceBlock> &interfaceBlocksToLink,
   ShaderType shaderType,
   bool webglCompatibility,
   InterfaceBlockMap *linkedBlocks,
   InfoLog &infoLog)
{
   ASSERT(linkedBlocks);

   for (const sh::InterfaceBlock &block : interfaceBlocksToLink)
   {
       const auto &entry = linkedBlocks->find(block.name);
       if (entry != linkedBlocks->end())
       {
           const sh::InterfaceBlock &linkedBlock = *(entry->second.second);
           std::string mismatchedStructFieldName;
           LinkMismatchError linkError = AreMatchingInterfaceBlocks(
               block, linkedBlock, webglCompatibility, &mismatchedStructFieldName);
           if (linkError != LinkMismatchError::NO_MISMATCH)
           {
               LogLinkMismatch(infoLog, block.name, GetInterfaceBlockTypeString(block.blockType),
                               linkError, mismatchedStructFieldName, entry->second.first,
                               shaderType);
               return false;
           }
       }
       else
       {
           (*linkedBlocks)[block.name] = std::make_pair(shaderType, &block);
       }
   }

   return true;
}

bool ValidateInterfaceBlocksMatch(
   GLuint numShadersHasInterfaceBlocks,
   const ShaderMap<const std::vector<sh::InterfaceBlock> *> &shaderInterfaceBlocks,
   InfoLog &infoLog,
   bool webglCompatibility,
   InterfaceBlockMap *instancelessInterfaceBlocksFields)
{
   for (ShaderType shaderType : kAllGraphicsShaderTypes)
   {
       // Validate that instanceless blocks of different names don't have fields of the same name.
       if (shaderInterfaceBlocks[shaderType] &&
           !ValidateInstancelessGraphicsInterfaceBlocksPerShader(
               *shaderInterfaceBlocks[shaderType], shaderType, instancelessInterfaceBlocksFields,
               infoLog))
       {
           return false;
       }
   }

   if (numShadersHasInterfaceBlocks < 2u)
   {
       return true;
   }

   ASSERT(!shaderInterfaceBlocks[ShaderType::Compute]);

   // Check that interface blocks defined in the graphics shaders are identical

   InterfaceBlockMap linkedInterfaceBlocks;

   bool interfaceBlockMapInitialized = false;
   for (ShaderType shaderType : kAllGraphicsShaderTypes)
   {
       if (!shaderInterfaceBlocks[shaderType])
       {
           continue;
       }

       if (!interfaceBlockMapInitialized)
       {
           InitializeInterfaceBlockMap(*shaderInterfaceBlocks[shaderType], shaderType,
                                       &linkedInterfaceBlocks);
           interfaceBlockMapInitialized = true;
       }
       else if (!ValidateGraphicsInterfaceBlocksPerShader(*shaderInterfaceBlocks[shaderType],
                                                          shaderType, webglCompatibility,
                                                          &linkedInterfaceBlocks, infoLog))
       {
           return false;
       }
   }

   return true;
}

bool LinkValidateProgramInterfaceBlocks(const Context *context,
                                       ShaderBitSet activeProgramStages,
                                       const ProgramLinkedResources &resources,
                                       InfoLog &infoLog,
                                       GLuint *combinedShaderStorageBlocksCountOut)
{
   ASSERT(combinedShaderStorageBlocksCountOut);

   const Caps &caps              = context->getCaps();
   const bool webglCompatibility = context->isWebGL();
   const Version &version        = context->getClientVersion();

   GLuint combinedUniformBlocksCount                                         = 0u;
   GLuint numShadersHasUniformBlocks                                         = 0u;
   ShaderMap<const std::vector<sh::InterfaceBlock> *> allShaderUniformBlocks = {};
   InterfaceBlockMap instancelessInterfaceBlocksFields;

   for (ShaderType shaderType : activeProgramStages)
   {
       const std::vector<sh::InterfaceBlock> &uniformBlocks =
           resources.uniformBlockLinker.getShaderBlocks(shaderType);
       if (!uniformBlocks.empty())
       {
           if (!ValidateInterfaceBlocksCount(
                   static_cast<GLuint>(caps.maxShaderUniformBlocks[shaderType]), uniformBlocks,
                   shaderType, sh::BlockType::BLOCK_UNIFORM, &combinedUniformBlocksCount, infoLog))
           {
               return false;
           }

           allShaderUniformBlocks[shaderType] = &uniformBlocks;
           ++numShadersHasUniformBlocks;
       }
   }

   if (combinedUniformBlocksCount > static_cast<GLuint>(caps.maxCombinedUniformBlocks))
   {
       infoLog << "The sum of the number of active uniform blocks exceeds "
                  "MAX_COMBINED_UNIFORM_BLOCKS ("
               << caps.maxCombinedUniformBlocks << ").";
       return false;
   }

   if (!ValidateInterfaceBlocksMatch(numShadersHasUniformBlocks, allShaderUniformBlocks, infoLog,
                                     webglCompatibility, &instancelessInterfaceBlocksFields))
   {
       return false;
   }

   if (version >= Version(3, 1))
   {
       *combinedShaderStorageBlocksCountOut                                      = 0u;
       GLuint numShadersHasShaderStorageBlocks                                   = 0u;
       ShaderMap<const std::vector<sh::InterfaceBlock> *> allShaderStorageBlocks = {};
       for (ShaderType shaderType : activeProgramStages)
       {
           const std::vector<sh::InterfaceBlock> &shaderStorageBlocks =
               resources.shaderStorageBlockLinker.getShaderBlocks(shaderType);
           if (!shaderStorageBlocks.empty())
           {
               if (!ValidateInterfaceBlocksCount(
                       static_cast<GLuint>(caps.maxShaderStorageBlocks[shaderType]),
                       shaderStorageBlocks, shaderType, sh::BlockType::BLOCK_BUFFER,
                       combinedShaderStorageBlocksCountOut, infoLog))
               {
                   return false;
               }

               allShaderStorageBlocks[shaderType] = &shaderStorageBlocks;
               ++numShadersHasShaderStorageBlocks;
           }
       }

       if (*combinedShaderStorageBlocksCountOut >
           static_cast<GLuint>(caps.maxCombinedShaderStorageBlocks))
       {
           infoLog << "The sum of the number of active shader storage blocks exceeds "
                      "MAX_COMBINED_SHADER_STORAGE_BLOCKS ("
                   << caps.maxCombinedShaderStorageBlocks << ").";
           return false;
       }

       if (!ValidateInterfaceBlocksMatch(numShadersHasShaderStorageBlocks, allShaderStorageBlocks,
                                         infoLog, webglCompatibility,
                                         &instancelessInterfaceBlocksFields))
       {
           return false;
       }
   }

   return true;
}

}  // namespace gl