Fix varying linking by location

src/libANGLE/Program.cpp

@@ -405,13 +405,19 @@ void InitShaderStorageBlockLinker(const ProgramState &state, ShaderStorageBlockL
 }
 
 // Find the matching varying or field by name.
-const sh::ShaderVariable *FindVaryingOrField(const ProgramMergedVaryings &varyings,
+const sh::ShaderVariable *FindOutputVaryingOrField(const ProgramMergedVaryings &varyings,
+                                                   ShaderType stage,
                                                    const std::string &name)
 {
     const sh::ShaderVariable *var = nullptr;
-    for (const auto &ref : varyings)
+    for (const ProgramVaryingRef &ref : varyings)
     {
-        const sh::ShaderVariable *varying = ref.second.get();
+        if (ref.frontShaderStage != stage)
+        {
+            continue;
+        }
+
+        const sh::ShaderVariable *varying = ref.get(stage);
         if (varying->name == name)
         {
             var = varying;
@@ -1583,7 +1589,7 @@ angle::Result Program::link(const Context *context)
             return angle::Result::Continue;
         }
 
-        const auto &mergedVaryings = getMergedVaryings();
+        const ProgramMergedVaryings &mergedVaryings = getMergedVaryings();
 
         gl::Shader *vertexShader = mState.mAttachedShaders[ShaderType::Vertex];
         if (vertexShader)
@@ -1594,8 +1600,11 @@ angle::Result Program::link(const Context *context)
         InitUniformBlockLinker(mState, &resources->uniformBlockLinker);
         InitShaderStorageBlockLinker(mState, &resources->shaderStorageBlockLinker);
 
+        ShaderType tfStage = mState.mAttachedShaders[ShaderType::Geometry] ? ShaderType::Geometry
+                                                                           : ShaderType::Vertex;
+
         if (!linkValidateTransformFeedback(context->getClientVersion(), mInfoLog, mergedVaryings,
-                                           context->getCaps()))
+                                           tfStage, context->getCaps()))
         {
             return angle::Result::Continue;
         }
@@ -1606,7 +1615,7 @@ angle::Result Program::link(const Context *context)
             return angle::Result::Continue;
         }
 
-        gatherTransformFeedbackVaryings(mergedVaryings);
+        gatherTransformFeedbackVaryings(mergedVaryings, tfStage);
         mState.updateTransformFeedbackStrides();
     }
 
@@ -4107,6 +4116,7 @@ bool Program::linkValidateBuiltInVaryings(InfoLog &infoLog) const
 bool Program::linkValidateTransformFeedback(const Version &version,
                                             InfoLog &infoLog,
                                             const ProgramMergedVaryings &varyings,
+                                            ShaderType stage,
                                             const Caps &caps) const
 {
 
@@ -4147,7 +4157,7 @@ bool Program::linkValidateTransformFeedback(const Version &version,
         std::vector<unsigned int> subscripts;
         std::string baseName = ParseResourceName(tfVaryingName, &subscripts);
 
-        const sh::ShaderVariable *var = FindVaryingOrField(varyings, baseName);
+        const sh::ShaderVariable *var = FindOutputVaryingOrField(varyings, stage, baseName);
         if (var == nullptr)
         {
             infoLog << "Transform feedback varying " << tfVaryingName
@@ -4328,7 +4338,8 @@ bool Program::linkValidateGlobalNames(InfoLog &infoLog) const
     return true;
 }
 
-void Program::gatherTransformFeedbackVaryings(const ProgramMergedVaryings &varyings)
+void Program::gatherTransformFeedbackVaryings(const ProgramMergedVaryings &varyings,
+                                              ShaderType stage)
 {
     // Gather the linked varyings that are used for transform feedback, they should all exist.
     mState.mLinkedTransformFeedbackVaryings.clear();
@@ -4341,9 +4352,14 @@ void Program::gatherTransformFeedbackVaryings(const ProgramMergedVaryings &varyi
         {
             subscript = subscripts.back();
         }
-        for (const auto &ref : varyings)
+        for (const ProgramVaryingRef &ref : varyings)
+        {
+            if (ref.frontShaderStage != stage)
             {
-            const sh::ShaderVariable *varying = ref.second.get();
+                continue;
+            }
+
+            const sh::ShaderVariable *varying = ref.get(stage);
             if (baseName == varying->name)
             {
                 mState.mLinkedTransformFeedbackVaryings.emplace_back(
@@ -4366,26 +4382,114 @@ void Program::gatherTransformFeedbackVaryings(const ProgramMergedVaryings &varyi
 
 ProgramMergedVaryings Program::getMergedVaryings() const
 {
+    ASSERT(mState.mAttachedShaders[ShaderType::Compute] == nullptr);
+
+    // Varyings are matched between pairs of consecutive stages, by location if assigned or
+    // by name otherwise.  Note that it's possible for one stage to specify location and the other
+    // not: https://cvs.khronos.org/bugzilla/show_bug.cgi?id=16261
+
+    // Map stages to the previous active stage in the rendering pipeline.  When looking at input
+    // varyings of a stage, this is used to find the stage whose output varyings are being linked
+    // with them.
+    ShaderMap<ShaderType> previousActiveStage;
+
+    // Note that kAllGraphicsShaderTypes is sorted according to the rendering pipeline.
+    ShaderType lastActiveStage = ShaderType::InvalidEnum;
+    for (ShaderType stage : kAllGraphicsShaderTypes)
+    {
+        previousActiveStage[stage] = lastActiveStage;
+        if (mState.mAttachedShaders[stage])
+        {
+            lastActiveStage = stage;
+        }
+    }
+
+    // First, go through output varyings and create two maps (one by name, one by location) for
+    // faster lookup when matching input varyings.
+
+    ShaderMap<std::map<std::string, size_t>> outputVaryingNameToIndex;
+    ShaderMap<std::map<int, size_t>> outputVaryingLocationToIndex;
+
     ProgramMergedVaryings merged;
 
+    // Gather output varyings.
     for (Shader *shader : mState.mAttachedShaders)
     {
-        if (shader)
+        if (!shader)
         {
-            ShaderType shaderType = shader->getType();
+            continue;
+        }
+        ShaderType stage = shader->getType();
+
         for (const sh::ShaderVariable &varying : shader->getOutputVaryings())
         {
-                ProgramVaryingRef *ref = &merged[varying.name];
+            merged.push_back({});
+            ProgramVaryingRef *ref = &merged.back();
+
             ref->frontShader      = &varying;
-                ref->frontShaderStage  = shaderType;
+            ref->frontShaderStage = stage;
+
+            // Always map by name.  Even if location is provided in this stage, it may not be in the
+            // paired stage.
+            outputVaryingNameToIndex[stage][varying.name] = merged.size() - 1;
+
+            // If location is provided, also keep it in a map by location.
+            if (varying.location != -1)
+            {
+                outputVaryingLocationToIndex[stage][varying.location] = merged.size() - 1;
+            }
+        }
+    }
+
+    // Gather input varyings, and match them with output varyings of the previous stage.
+    for (Shader *shader : mState.mAttachedShaders)
+    {
+        if (!shader)
+        {
+            continue;
         }
+        ShaderType stage         = shader->getType();
+        ShaderType previousStage = previousActiveStage[stage];
+
         for (const sh::ShaderVariable &varying : shader->getInputVaryings())
         {
-                ProgramVaryingRef *ref = &merged[varying.name];
-                ref->backShader        = &varying;
-                ref->backShaderStage   = shaderType;
+            size_t mergedIndex = merged.size();
+            if (previousStage != ShaderType::InvalidEnum)
+            {
+                // If location is provided, see if we can match by location.
+                if (varying.location != -1)
+                {
+                    auto byLocationIter =
+                        outputVaryingLocationToIndex[previousStage].find(varying.location);
+                    if (byLocationIter != outputVaryingLocationToIndex[previousStage].end())
+                    {
+                        mergedIndex = byLocationIter->second;
+                    }
+                }
+
+                // If not found, try to match by name.
+                if (mergedIndex == merged.size())
+                {
+                    auto byNameIter = outputVaryingNameToIndex[previousStage].find(varying.name);
+                    if (byNameIter != outputVaryingNameToIndex[previousStage].end())
+                    {
+                        mergedIndex = byNameIter->second;
+                    }
                 }
             }
+
+            // If no previous stage, or not matched by location or name, create a new entry for it.
+            if (mergedIndex == merged.size())
+            {
+                merged.push_back({});
+                mergedIndex = merged.size() - 1;
+            }
+
+            ProgramVaryingRef *ref = &merged[mergedIndex];
+
+            ref->backShader      = &varying;
+            ref->backShaderStage = stage;
+        }
     }
 
     return merged;

src/libANGLE/Program.h

@@ -568,7 +568,13 @@ class ProgramAliasedBindings final : angle::NonCopyable
 
 struct ProgramVaryingRef
 {
-    const sh::ShaderVariable *get() const { return frontShader ? frontShader : backShader; }
+    const sh::ShaderVariable *get(ShaderType stage) const
+    {
+        ASSERT(stage == frontShaderStage || stage == backShaderStage);
+        const sh::ShaderVariable *ref = stage == frontShaderStage ? frontShader : backShader;
+        ASSERT(ref);
+        return ref;
+    }
 
     const sh::ShaderVariable *frontShader = nullptr;
     const sh::ShaderVariable *backShader  = nullptr;
@@ -576,7 +582,7 @@ struct ProgramVaryingRef
     ShaderType backShaderStage            = ShaderType::InvalidEnum;
 };
 
-using ProgramMergedVaryings = std::map<std::string, ProgramVaryingRef>;
+using ProgramMergedVaryings = std::vector<ProgramVaryingRef>;
 
 class Program final : angle::NonCopyable, public LabeledObject
 {
@@ -1025,10 +1031,11 @@ class Program final : angle::NonCopyable, public LabeledObject
     bool linkValidateTransformFeedback(const Version &version,
                                        InfoLog &infoLog,
                                        const ProgramMergedVaryings &linkedVaryings,
+                                       ShaderType stage,
                                        const Caps &caps) const;
     bool linkValidateGlobalNames(InfoLog &infoLog) const;
 
-    void gatherTransformFeedbackVaryings(const ProgramMergedVaryings &varyings);
+    void gatherTransformFeedbackVaryings(const ProgramMergedVaryings &varyings, ShaderType stage);
 
     ProgramMergedVaryings getMergedVaryings() const;
     int getOutputLocationForLink(const sh::ShaderVariable &outputVariable) const;

src/libANGLE/VaryingPacking.cpp

@@ -28,47 +28,65 @@ bool ComparePackedVarying(const PackedVarying &x, const PackedVarying &y)
     // non-array shader variable 'vx' or 'vy' for actual comparison instead.
     sh::ShaderVariable vx, vy;
     const sh::ShaderVariable *px, *py;
+
+    px = &x.varying();
+    py = &y.varying();
+
     if (x.isArrayElement())
     {
-        vx = *x.varying;
+        vx = *px;
         vx.arraySizes.clear();
         px = &vx;
     }
-    else
-    {
-        px = x.varying;
-    }
 
     if (y.isArrayElement())
     {
-        vy = *y.varying;
+        vy = *py;
         vy.arraySizes.clear();
         py = &vy;
     }
-    else
-    {
-        py = y.varying;
-    }
 
     return gl::CompareShaderVar(*px, *py);
 }
 
 }  // anonymous namespace
 
+// Implementation of VaryingInShaderRef
+VaryingInShaderRef::VaryingInShaderRef(ShaderType stageIn, const sh::ShaderVariable *varyingIn)
+    : varying(varyingIn), stage(stageIn)
+{}
+
+VaryingInShaderRef::~VaryingInShaderRef() = default;
+
+VaryingInShaderRef::VaryingInShaderRef(VaryingInShaderRef &&other)
+{
+    *this = std::move(other);
+}
+
+VaryingInShaderRef &VaryingInShaderRef::operator=(VaryingInShaderRef &&other)
+{
+    std::swap(varying, other.varying);
+    std::swap(stage, other.stage);
+    std::swap(parentStructName, other.parentStructName);
+    std::swap(parentStructMappedName, other.parentStructMappedName);
+
+    return *this;
+}
+
 // Implementation of PackedVarying
-PackedVarying::PackedVarying(const sh::ShaderVariable &varyingIn,
+PackedVarying::PackedVarying(VaryingInShaderRef &&frontVaryingIn,
+                             VaryingInShaderRef &&backVaryingIn,
                              sh::InterpolationType interpolationIn)
-    : PackedVarying(varyingIn, interpolationIn, "", "", false)
+    : PackedVarying(std::move(frontVaryingIn), std::move(backVaryingIn), interpolationIn, 0)
 {}
-PackedVarying::PackedVarying(const sh::ShaderVariable &varyingIn,
+
+PackedVarying::PackedVarying(VaryingInShaderRef &&frontVaryingIn,
+                             VaryingInShaderRef &&backVaryingIn,
                              sh::InterpolationType interpolationIn,
-                             const std::string &parentStructNameIn,
-                             const std::string &parentStructMappedNameIn,
                              GLuint fieldIndexIn)
-    : varying(&varyingIn),
+    : frontVarying(std::move(frontVaryingIn)),
+      backVarying(std::move(backVaryingIn)),
       interpolation(interpolationIn),
-      parentStructName(parentStructNameIn),
-      parentStructMappedName(parentStructMappedNameIn),
       arrayIndex(GL_INVALID_INDEX),
       fieldIndex(fieldIndexIn)
 {}
@@ -76,17 +94,17 @@ PackedVarying::PackedVarying(const sh::ShaderVariable &varyingIn,
 PackedVarying::~PackedVarying() = default;
 
 PackedVarying::PackedVarying(PackedVarying &&other)
-    : PackedVarying(*other.varying, other.interpolation)
+    : frontVarying(other.frontVarying.stage, other.frontVarying.varying),
+      backVarying(other.backVarying.stage, other.backVarying.varying)
 {
     *this = std::move(other);
 }
+
 PackedVarying &PackedVarying::operator=(PackedVarying &&other)
 {
-    std::swap(varying, other.varying);
-    std::swap(shaderStages, other.shaderStages);
+    std::swap(frontVarying, other.frontVarying);
+    std::swap(backVarying, other.backVarying);
     std::swap(interpolation, other.interpolation);
-    std::swap(parentStructName, other.parentStructName);
-    std::swap(parentStructMappedName, other.parentStructMappedName);
     std::swap(arrayIndex, other.arrayIndex);
     std::swap(fieldIndex, other.fieldIndex);
 
@@ -106,7 +124,7 @@ VaryingPacking::~VaryingPacking() = default;
 // Returns false if unsuccessful.
 bool VaryingPacking::packVarying(const PackedVarying &packedVarying)
 {
-    const sh::ShaderVariable &varying = *packedVarying.varying;
+    const sh::ShaderVariable &varying = packedVarying.varying();
 
     // "Non - square matrices of type matCxR consume the same space as a square matrix of type matN
     // where N is the greater of C and R."
@@ -234,7 +252,7 @@ bool VaryingPacking::packVarying(const PackedVarying &packedVarying)
                     registerInfo.varyingRowIndex = 0;
                     // Do not record register info for builtins.
                     // TODO(jmadill): Clean this up.
-                    if (!packedVarying.varying->isBuiltIn())
+                    if (!varying.isBuiltIn())
                     {
                         mRegisterList.push_back(registerInfo);
                     }
@@ -277,7 +295,7 @@ void VaryingPacking::insert(unsigned int registerRow,
     unsigned int varyingRows    = 0;
     unsigned int varyingColumns = 0;
 
-    const auto &varying = *packedVarying.varying;
+    const sh::ShaderVariable &varying = packedVarying.varying();
     ASSERT(!varying.isStruct());
     GLenum transposedType = gl::TransposeMatrixType(varying.type);
     varyingRows           = gl::VariableRowCount(transposedType);
@@ -303,7 +321,7 @@ void VaryingPacking::insert(unsigned int registerRow,
             registerInfo.varyingArrayIndex = arrayElement;
             // Do not record register info for builtins.
             // TODO(jmadill): Clean this up.
-            if (!packedVarying.varying->isBuiltIn())
+            if (!varying.isBuiltIn())
             {
                 mRegisterList.push_back(registerInfo);
             }
@@ -316,26 +334,114 @@ void VaryingPacking::insert(unsigned int registerRow,
     }
 }
 
-bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
-                                                const ProgramMergedVaryings &mergedVaryings,
-                                                const std::vector<std::string> &tfVaryings)
+void VaryingPacking::packUserVarying(const ProgramVaryingRef &ref,
+                                     VaryingUniqueFullNames *uniqueFullNames)
 {
-    std::set<std::string> uniqueFullNames;
-    mPackedVaryings.clear();
-    mInputVaryings.clear();
+    const sh::ShaderVariable *input  = ref.frontShader;
+    const sh::ShaderVariable *output = ref.backShader;
+
+    // Will get the vertex shader interpolation by default.
+    sh::InterpolationType interpolation = input ? input->interpolation : output->interpolation;
 
-    for (const auto &ref : mergedVaryings)
+    VaryingInShaderRef frontVarying(ref.frontShaderStage, input);
+    VaryingInShaderRef backVarying(ref.backShaderStage, output);
+
+    mPackedVaryings.emplace_back(std::move(frontVarying), std::move(backVarying), interpolation);
+    if (input)
+    {
+        (*uniqueFullNames)[ref.frontShaderStage].insert(
+            mPackedVaryings.back().fullName(ref.frontShaderStage));
+    }
+    if (output)
     {
-        const sh::ShaderVariable *input  = ref.second.frontShader;
-        const sh::ShaderVariable *output = ref.second.backShader;
+        (*uniqueFullNames)[ref.backShaderStage].insert(
+            mPackedVaryings.back().fullName(ref.backShaderStage));
+    }
+}
+
+void VaryingPacking::packUserVaryingField(const ProgramVaryingRef &ref,
+                                          GLuint fieldIndex,
+                                          VaryingUniqueFullNames *uniqueFullNames)
+{
+    const sh::ShaderVariable *input  = ref.frontShader;
+    const sh::ShaderVariable *output = ref.backShader;
+
+    // Will get the vertex shader interpolation by default.
+    sh::InterpolationType interpolation = input ? input->interpolation : output->interpolation;
+
+    const sh::ShaderVariable *frontField = input ? &input->fields[fieldIndex] : nullptr;
+    const sh::ShaderVariable *backField  = output ? &output->fields[fieldIndex] : nullptr;
+
+    VaryingInShaderRef frontVarying(ref.frontShaderStage, frontField);
+    VaryingInShaderRef backVarying(ref.backShaderStage, backField);
+
     if (input)
     {
-            mInputVaryings.emplace_back(*input);
+        ASSERT(!frontField->isStruct() && !frontField->isArray());
+        frontVarying.parentStructName       = input->name;
+        frontVarying.parentStructMappedName = input->mappedName;
+    }
+    if (output)
+    {
+        ASSERT(!backField->isStruct() && !backField->isArray());
+        backVarying.parentStructName       = output->name;
+        backVarying.parentStructMappedName = output->mappedName;
+    }
+
+    mPackedVaryings.emplace_back(std::move(frontVarying), std::move(backVarying), interpolation,
+                                 fieldIndex);
+
+    if (input)
+    {
+        (*uniqueFullNames)[ref.frontShaderStage].insert(
+            mPackedVaryings.back().fullName(ref.frontShaderStage));
+    }
+    if (output)
+    {
+        (*uniqueFullNames)[ref.backShaderStage].insert(
+            mPackedVaryings.back().fullName(ref.backShaderStage));
     }
+}
+
+void VaryingPacking::packUserVaryingTF(const ProgramVaryingRef &ref, size_t subscript)
+{
+    const sh::ShaderVariable *input = ref.frontShader;
+
+    VaryingInShaderRef frontVarying(ref.frontShaderStage, input);
+    VaryingInShaderRef backVarying(ref.backShaderStage, nullptr);
+
+    mPackedVaryings.emplace_back(std::move(frontVarying), std::move(backVarying),
+                                 input->interpolation);
+    mPackedVaryings.back().arrayIndex = static_cast<GLuint>(subscript);
+}
+
+void VaryingPacking::packUserVaryingFieldTF(const ProgramVaryingRef &ref,
+                                            const sh::ShaderVariable &field,
+                                            GLuint fieldIndex)
+{
+    const sh::ShaderVariable *input = ref.frontShader;
+
+    VaryingInShaderRef frontVarying(ref.frontShaderStage, &field);
+    VaryingInShaderRef backVarying(ref.backShaderStage, nullptr);
+
+    frontVarying.parentStructName       = input->name;
+    frontVarying.parentStructMappedName = input->mappedName;
 
-        ShaderBitSet shaderStages;
-        shaderStages.set(ref.second.frontShaderStage);
-        shaderStages.set(ref.second.backShaderStage);
+    mPackedVaryings.emplace_back(std::move(frontVarying), std::move(backVarying),
+                                 input->interpolation, fieldIndex);
+}
+
+bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
+                                                const ProgramMergedVaryings &mergedVaryings,
+                                                const std::vector<std::string> &tfVaryings)
+{
+    VaryingUniqueFullNames uniqueFullNames;
+    mPackedVaryings.clear();
+
+    for (const ProgramVaryingRef &ref : mergedVaryings)
+    {
+        const sh::ShaderVariable *input  = ref.frontShader;
+        const sh::ShaderVariable *output = ref.backShader;
 
         // Only pack statically used varyings that have a matched input or output, plus special
         // builtins. Note that we pack all statically used user-defined varyings even if they are
@@ -353,31 +459,26 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
                 !(varying->name == "gl_PointSize" &&
                   mPackMode == PackMode::ANGLE_NON_CONFORMANT_D3D9))
             {
-                // Will get the vertex shader interpolation by default.
-                auto interpolation = ref.second.get()->interpolation;
-
-                // Note that we lose the vertex shader static use information here. The data for the
-                // variable is taken from the fragment shader.
                 if (varying->isStruct())
                 {
                     ASSERT(!(varying->isArray() && varying == input));
+
                     for (GLuint fieldIndex = 0; fieldIndex < varying->fields.size(); ++fieldIndex)
                     {
-                        const sh::ShaderVariable &field = varying->fields[fieldIndex];
-
-                        ASSERT(!field.isStruct() && !field.isArray());
-                        mPackedVaryings.emplace_back(field, interpolation, varying->name,
-                                                     varying->mappedName, fieldIndex);
-                        mPackedVaryings.back().shaderStages = shaderStages;
-                        uniqueFullNames.insert(mPackedVaryings.back().fullName());
+                        packUserVaryingField(ref, fieldIndex, &uniqueFullNames);
+                    }
+                    if (input)
+                    {
+                        uniqueFullNames[ref.frontShaderStage].insert(input->name);
+                    }
+                    if (output)
+                    {
+                        uniqueFullNames[ref.backShaderStage].insert(output->name);
                     }
-                    uniqueFullNames.insert(varying->name);
                 }
                 else
                 {
-                    mPackedVaryings.emplace_back(*varying, interpolation);
-                    mPackedVaryings.back().shaderStages = shaderStages;
-                    uniqueFullNames.insert(mPackedVaryings.back().fullName());
+                    packUserVarying(ref, &uniqueFullNames);
                 }
                 continue;
             }
@@ -386,7 +487,7 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
         // If the varying is not used in the input, we know it is inactive.
         if (!input)
         {
-            mInactiveVaryingMappedNames.push_back(output->mappedName);
+            mInactiveVaryingMappedNames[ref.backShaderStage].push_back(output->mappedName);
             continue;
         }
 
@@ -401,7 +502,8 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
                 subscript = subscripts.back();
             }
             // Already packed for fragment shader.
-            if (uniqueFullNames.count(tfVarying) > 0 || uniqueFullNames.count(baseName) > 0)
+            if (uniqueFullNames[ref.frontShaderStage].count(tfVarying) > 0 ||
+                uniqueFullNames[ref.frontShaderStage].count(baseName) > 0)
             {
                 continue;
             }
@@ -413,13 +515,11 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
                 if (field != nullptr)
                 {
                     ASSERT(!field->isStruct() && !field->isArray());
-                    mPackedVaryings.emplace_back(*field, input->interpolation, input->name,
-                                                 input->mappedName, fieldIndex);
-                    mPackedVaryings.back().shaderStages.set(ShaderType::Vertex);
-                    mPackedVaryings.back().arrayIndex = GL_INVALID_INDEX;
-                    uniqueFullNames.insert(tfVarying);
+
+                    packUserVaryingFieldTF(ref, *field, fieldIndex);
+                    uniqueFullNames[ref.frontShaderStage].insert(tfVarying);
                 }
-                uniqueFullNames.insert(input->name);
+                uniqueFullNames[ref.frontShaderStage].insert(input->name);
             }
             // Array as a whole and array element conflict has already been checked in
             // linkValidateTransformFeedback.
@@ -428,10 +528,8 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
                 // only pack varyings that are not builtins.
                 if (tfVarying.compare(0, 3, "gl_") != 0)
                 {
-                    mPackedVaryings.emplace_back(*input, input->interpolation);
-                    mPackedVaryings.back().shaderStages.set(ShaderType::Vertex);
-                    mPackedVaryings.back().arrayIndex = static_cast<GLuint>(subscript);
-                    uniqueFullNames.insert(tfVarying);
+                    packUserVaryingTF(ref, subscript);
+                    uniqueFullNames[ref.frontShaderStage].insert(tfVarying);
                 }
                 // Continue to match next array element for 'input' if the current match is array
                 // element.
@@ -442,9 +540,13 @@ bool VaryingPacking::collectAndPackUserVaryings(gl::InfoLog &infoLog,
             }
         }
 
-        if (uniqueFullNames.count(ref.first) == 0)
+        if (input && uniqueFullNames[ref.frontShaderStage].count(input->name) == 0)
+        {
+            mInactiveVaryingMappedNames[ref.frontShaderStage].push_back(input->mappedName);
+        }
+        if (output && uniqueFullNames[ref.backShaderStage].count(output->name) == 0)
         {
-            mInactiveVaryingMappedNames.push_back(input->mappedName);
+            mInactiveVaryingMappedNames[ref.backShaderStage].push_back(output->mappedName);
         }
     }
 
@@ -463,7 +565,10 @@ bool VaryingPacking::packUserVaryings(gl::InfoLog &infoLog,
     {
         if (!packVarying(packedVarying))
         {
-            infoLog << "Could not pack varying " << packedVarying.fullName();
+            ShaderType eitherStage = packedVarying.frontVarying.varying
+                                         ? packedVarying.frontVarying.stage
+                                         : packedVarying.backVarying.stage;
+            infoLog << "Could not pack varying " << packedVarying.fullName(eitherStage);
 
             // TODO(jmadill): Implement more sophisticated component packing in D3D9.
             if (mPackMode == PackMode::ANGLE_NON_CONFORMANT_D3D9)

src/libANGLE/VaryingPacking.h

@@ -25,34 +25,77 @@ namespace gl
 class InfoLog;
 struct ProgramVaryingRef;
 
-using ProgramMergedVaryings = std::map<std::string, ProgramVaryingRef>;
+using ProgramMergedVaryings = std::vector<ProgramVaryingRef>;
+
+// A varying can have different names between stages if matched by the location layout qualifier.
+// Additionally, same name varyings could still be of two identical struct types with different
+// names.  This struct contains information on the varying in one of the two stages.  PackedVarying
+// will thus contain two copies of this along with common information, such as interpolation or
+// field index.
+struct VaryingInShaderRef : angle::NonCopyable
+{
+    VaryingInShaderRef(ShaderType stageIn, const sh::ShaderVariable *varyingIn);
+    VaryingInShaderRef(VaryingInShaderRef &&other);
+    ~VaryingInShaderRef();
+
+    VaryingInShaderRef &operator=(VaryingInShaderRef &&other);
+
+    const sh::ShaderVariable *varying;
+
+    ShaderType stage;
+
+    // Struct name
+    std::string parentStructName;
+    std::string parentStructMappedName;
+};
 
 struct PackedVarying : angle::NonCopyable
 {
-    PackedVarying(const sh::ShaderVariable &varyingIn, sh::InterpolationType interpolationIn);
-    PackedVarying(const sh::ShaderVariable &varyingIn,
+    // Throughout this file, the "front" stage refers to the stage that outputs the varying, and the
+    // "back" stage refers to the stage that takes the varying as input.  Note that this struct
+    // contains linked varyings, which means both front and back stage varyings are valid, except
+    // for the following which may have only one valid stage.
+    //
+    //  - transform-feedback-captured varyings
+    //  - builtins
+    //  - separable program stages,
+    //
+    PackedVarying(VaryingInShaderRef &&frontVaryingIn,
+                  VaryingInShaderRef &&backVaryingIn,
+                  sh::InterpolationType interpolationIn);
+    PackedVarying(VaryingInShaderRef &&frontVaryingIn,
+                  VaryingInShaderRef &&backVaryingIn,
                   sh::InterpolationType interpolationIn,
-                  const std::string &parentStructNameIn,
-                  const std::string &parentStructMappedNameIn,
                   GLuint fieldIndexIn);
     PackedVarying(PackedVarying &&other);
     ~PackedVarying();
 
     PackedVarying &operator=(PackedVarying &&other);
 
-    bool isStructField() const { return !parentStructName.empty(); }
+    bool isStructField() const { return !frontVarying.parentStructName.empty(); }
 
     bool isArrayElement() const { return arrayIndex != GL_INVALID_INDEX; }
 
-    std::string fullName() const
+    // Return either front or back varying, whichever is available.  Only used when the name of the
+    // varying is not important, but only the type is interesting.
+    const sh::ShaderVariable &varying() const
+    {
+        return frontVarying.varying ? *frontVarying.varying : *backVarying.varying;
+    }
+
+    std::string fullName(ShaderType stage) const
     {
+        ASSERT(stage == frontVarying.stage || stage == backVarying.stage);
+        const VaryingInShaderRef &varying =
+            stage == frontVarying.stage ? frontVarying : backVarying;
+
         std::stringstream fullNameStr;
         if (isStructField())
         {
-            fullNameStr << parentStructName << ".";
+            fullNameStr << varying.parentStructName << ".";
         }
 
-        fullNameStr << varying->name;
+        fullNameStr << varying.varying->name;
         if (arrayIndex != GL_INVALID_INDEX)
         {
             fullNameStr << "[" << arrayIndex << "]";
@@ -63,22 +106,15 @@ struct PackedVarying : angle::NonCopyable
     // Transform feedback varyings can be only referenced in the VS.
     bool vertexOnly() const
     {
-        ShaderBitSet vertex;
-        vertex.set(ShaderType::Vertex);
-        return shaderStages == vertex;
+        return frontVarying.stage == ShaderType::Vertex && backVarying.varying == nullptr;
     }
 
-    const sh::ShaderVariable *varying;
-
-    ShaderBitSet shaderStages;
+    VaryingInShaderRef frontVarying;
+    VaryingInShaderRef backVarying;
 
     // Cached so we can store sh::ShaderVariable to point to varying fields.
     sh::InterpolationType interpolation;
 
-    // Struct name
-    std::string parentStructName;
-    std::string parentStructMappedName;
-
     GLuint arrayIndex;
 
     // Field index in the struct.  In Vulkan, this is used to assign a
@@ -112,14 +148,7 @@ struct PackedVaryingRegister final
 
     std::string tfVaryingName() const
     {
-        if (packedVarying->isArrayElement() || packedVarying->isStructField())
-        {
-            return packedVarying->fullName();
-        }
-        else
-        {
-            return packedVarying->varying->name;
-        }
+        return packedVarying->fullName(packedVarying->frontVarying.stage);
     }
 
     // Index to the array of varyings.
@@ -182,13 +211,11 @@ class VaryingPacking final : angle::NonCopyable
         return static_cast<unsigned int>(mRegisterList.size());
     }
 
-    const std::vector<std::string> &getInactiveVaryingMappedNames() const
+    const ShaderMap<std::vector<std::string>> &getInactiveVaryingMappedNames() const
     {
         return mInactiveVaryingMappedNames;
     }
 
-    const std::vector<sh::ShaderVariable> &getInputVaryings() const { return mInputVaryings; }
-
   private:
     bool packVarying(const PackedVarying &packedVarying);
     bool isFree(unsigned int registerRow,
@@ -199,11 +226,20 @@ class VaryingPacking final : angle::NonCopyable
                 unsigned int registerColumn,
                 const PackedVarying &packedVarying);
 
+    using VaryingUniqueFullNames = ShaderMap<std::set<std::string>>;
+    void packUserVarying(const ProgramVaryingRef &ref, VaryingUniqueFullNames *uniqueFullNames);
+    void packUserVaryingField(const ProgramVaryingRef &ref,
+                              GLuint fieldIndex,
+                              VaryingUniqueFullNames *uniqueFullNames);
+    void packUserVaryingTF(const ProgramVaryingRef &ref, size_t subscript);
+    void packUserVaryingFieldTF(const ProgramVaryingRef &ref,
+                                const sh::ShaderVariable &field,
+                                GLuint fieldIndex);
+
     std::vector<Register> mRegisterMap;
     std::vector<PackedVaryingRegister> mRegisterList;
-    std::vector<sh::ShaderVariable> mInputVaryings;
     std::vector<PackedVarying> mPackedVaryings;
-    std::vector<std::string> mInactiveVaryingMappedNames;
+    ShaderMap<std::vector<std::string>> mInactiveVaryingMappedNames;
 
     PackMode mPackMode;
 };

src/libANGLE/VaryingPacking_unittest.cpp

@@ -30,9 +30,11 @@ class VaryingPackingTest : public ::testing::TestWithParam<GLuint>
                             VaryingPacking *varyingPacking)
     {
         std::vector<PackedVarying> packedVaryings;
-        for (const auto &shVarying : shVaryings)
+        for (const sh::ShaderVariable &shVarying : shVaryings)
         {
-            packedVaryings.push_back(PackedVarying(shVarying, shVarying.interpolation));
+            packedVaryings.push_back(PackedVarying(
+                VaryingInShaderRef(ShaderType::Vertex, &shVarying),
+                VaryingInShaderRef(ShaderType::Fragment, &shVarying), shVarying.interpolation));
         }
 
         InfoLog infoLog;

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -414,7 +414,7 @@ void DynamicHLSL::generateVaryingLinkHLSL(const VaryingPacking &varyingPacking,
     for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex)
     {
         const PackedVaryingRegister &registerInfo = registerInfos[registerIndex];
-        const auto &varying                       = *registerInfo.packedVarying->varying;
+        const auto &varying                       = registerInfo.packedVarying->varying();
         ASSERT(!varying.isStruct());
 
         // TODO: Add checks to ensure D3D interpolation modifiers don't result in too many
@@ -599,14 +599,15 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::Caps &caps,
     {
         const PackedVaryingRegister &registerInfo = registerInfos[registerIndex];
         const auto &packedVarying                 = *registerInfo.packedVarying;
-        const auto &varying                       = *packedVarying.varying;
+        const auto &varying                       = *packedVarying.frontVarying.varying;
         ASSERT(!varying.isStruct());
 
         vertexGenerateOutput << "    output.v" << registerIndex << " = ";
 
         if (packedVarying.isStructField())
         {
-            vertexGenerateOutput << DecorateVariable(packedVarying.parentStructName) << ".";
+            vertexGenerateOutput << DecorateVariable(packedVarying.frontVarying.parentStructName)
+                                 << ".";
         }
 
         vertexGenerateOutput << DecorateVariable(varying.name);
@@ -798,19 +799,28 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::Caps &caps,
     {
         const PackedVaryingRegister &registerInfo = registerInfos[registerIndex];
         const auto &packedVarying                 = *registerInfo.packedVarying;
-        const auto &varying                       = *packedVarying.varying;
+
+        // Don't reference VS-only transform feedback varyings in the PS.
+        if (packedVarying.vertexOnly())
+        {
+            continue;
+        }
+
+        const auto &varying = *packedVarying.backVarying.varying;
         ASSERT(!varying.isBuiltIn() && !varying.isStruct());
 
-        // Don't reference VS-only transform feedback varyings in the PS. Note that we're relying on
-        // that the active flag is set according to usage in the fragment shader.
-        if (packedVarying.vertexOnly() || !varying.active)
+        // Note that we're relying on that the active flag is set according to usage in the fragment
+        // shader.
+        if (!varying.active)
+        {
             continue;
+        }
 
         pixelPrologue << "    ";
 
         if (packedVarying.isStructField())
         {
-            pixelPrologue << DecorateVariable(packedVarying.parentStructName) << ".";
+            pixelPrologue << DecorateVariable(packedVarying.backVarying.parentStructName) << ".";
         }
 
         pixelPrologue << DecorateVariable(varying.name);

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -3141,7 +3141,7 @@ void ProgramD3D::gatherTransformFeedbackVaryings(const gl::VaryingPacking &varyi
             for (GLuint registerIndex = 0u; registerIndex < registerInfos.size(); ++registerIndex)
             {
                 const auto &registerInfo = registerInfos[registerIndex];
-                const auto &varying      = *registerInfo.packedVarying->varying;
+                const auto &varying      = registerInfo.packedVarying->varying();
                 GLenum transposedType    = gl::TransposeMatrixType(varying.type);
                 int componentCount       = gl::VariableColumnCount(transposedType);
                 ASSERT(!varying.isBuiltIn() && !varying.isStruct());

src/libANGLE/renderer/glslang_wrapper_utils.cpp

@@ -237,23 +237,20 @@ ShaderInterfaceVariableInfo *AddLocationInfo(ShaderInterfaceVariableInfoMap *inf
                                              const std::string &varName,
                                              uint32_t location,
                                              uint32_t component,
-                                             gl::ShaderBitSet activeStages)
+                                             gl::ShaderType stage)
 {
     // The info map for this name may or may not exist already.  This function merges the
     // location/component information.
     ShaderInterfaceVariableInfo *info = &(*infoMap)[varName];
 
-    for (const gl::ShaderType shaderType : activeStages)
-    {
     ASSERT(info->descriptorSet == ShaderInterfaceVariableInfo::kInvalid);
     ASSERT(info->binding == ShaderInterfaceVariableInfo::kInvalid);
-        ASSERT(info->location[shaderType] == ShaderInterfaceVariableInfo::kInvalid);
-        ASSERT(info->component[shaderType] == ShaderInterfaceVariableInfo::kInvalid);
+    ASSERT(info->location[stage] == ShaderInterfaceVariableInfo::kInvalid);
+    ASSERT(info->component[stage] == ShaderInterfaceVariableInfo::kInvalid);
 
-        info->location[shaderType]  = location;
-        info->component[shaderType] = component;
-    }
-    info->activeStages |= activeStages;
+    info->location[stage]  = location;
+    info->component[stage] = component;
+    info->activeStages.set(stage);
 
     return info;
 }
@@ -489,16 +486,13 @@ void GenerateTransformFeedbackExtensionOutputs(const gl::ProgramState &programSt
 void AssignAttributeLocations(const gl::ProgramState &programState,
                               ShaderInterfaceVariableInfoMap *variableInfoMapOut)
 {
-    gl::ShaderBitSet vertexOnly;
-    vertexOnly.set(gl::ShaderType::Vertex);
-
     // Assign attribute locations for the vertex shader.
     for (const sh::ShaderVariable &attribute : programState.getProgramInputs())
     {
         ASSERT(attribute.active);
 
         AddLocationInfo(variableInfoMapOut, attribute.mappedName, attribute.location,
-                        ShaderInterfaceVariableInfo::kInvalid, vertexOnly);
+                        ShaderInterfaceVariableInfo::kInvalid, gl::ShaderType::Vertex);
     }
 }
 
@@ -512,9 +506,6 @@ void AssignOutputLocations(const gl::ProgramState &programState,
     const std::array<std::string, 3> implicitOutputs = {"gl_FragDepth", "gl_SampleMask",
                                                         "gl_FragStencilRefARB"};
 
-    gl::ShaderBitSet fragmentOnly;
-    fragmentOnly.set(gl::ShaderType::Fragment);
-
     for (const gl::VariableLocation &outputLocation : outputLocations)
     {
         if (outputLocation.arrayIndex == 0 && outputLocation.used() && !outputLocation.ignored)
@@ -536,7 +527,7 @@ void AssignOutputLocations(const gl::ProgramState &programState,
             }
 
             AddLocationInfo(variableInfoMapOut, outputVar.mappedName, location,
-                            ShaderInterfaceVariableInfo::kInvalid, fragmentOnly);
+                            ShaderInterfaceVariableInfo::kInvalid, gl::ShaderType::Fragment);
         }
     }
 
@@ -545,8 +536,8 @@ void AssignOutputLocations(const gl::ProgramState &programState,
     // location 0 to these entries, adding an entry for them here allows us to ASSERT that every
     // shader interface variable is processed during the SPIR-V transformation.  This is done when
     // iterating the ids provided by OpEntryPoint.
-    AddLocationInfo(variableInfoMapOut, "webgl_FragColor", 0, 0, fragmentOnly);
-    AddLocationInfo(variableInfoMapOut, "webgl_FragData", 0, 0, fragmentOnly);
+    AddLocationInfo(variableInfoMapOut, "webgl_FragColor", 0, 0, gl::ShaderType::Fragment);
+    AddLocationInfo(variableInfoMapOut, "webgl_FragData", 0, 0, gl::ShaderType::Fragment);
 }
 
 void AssignVaryingLocations(const GlslangSourceOptions &options,
@@ -563,12 +554,12 @@ void AssignVaryingLocations(const GlslangSourceOptions &options,
     {
         uint32_t lineRasterEmulationPositionLocation = locationsUsedForEmulation++;
 
-        gl::ShaderBitSet allActiveStages;
-        allActiveStages.set();
-
+        for (const gl::ShaderType shaderType : programState.getLinkedShaderStages())
+        {
             AddLocationInfo(variableInfoMapOut, sh::vk::kLineRasterEmulationPosition,
-                        lineRasterEmulationPositionLocation, ShaderInterfaceVariableInfo::kInvalid,
-                        allActiveStages);
+                            lineRasterEmulationPositionLocation,
+                            ShaderInterfaceVariableInfo::kInvalid, shaderType);
+        }
     }
 
     // Assign varying locations.
@@ -581,6 +572,15 @@ void AssignVaryingLocations(const GlslangSourceOptions &options,
 
         const gl::PackedVarying &varying = *varyingReg.packedVarying;
 
+        uint32_t location  = varyingReg.registerRow + locationsUsedForEmulation;
+        uint32_t component = ShaderInterfaceVariableInfo::kInvalid;
+        if (varyingReg.registerColumn > 0)
+        {
+            ASSERT(!varying.varying().isStruct());
+            ASSERT(!gl::IsMatrixType(varying.varying().type));
+            component = varyingReg.registerColumn;
+        }
+
         // In the following:
         //
         //     struct S { vec4 field; };
@@ -588,23 +588,30 @@ void AssignVaryingLocations(const GlslangSourceOptions &options,
         //
         // "_uvarStruct" is found through |parentStructMappedName|, with |varying->mappedName|
         // being "_ufield".  In such a case, use |parentStructMappedName|.
-        const std::string &name =
-            varying.isStructField() ? varying.parentStructMappedName : varying.varying->mappedName;
-
-        uint32_t location  = varyingReg.registerRow + locationsUsedForEmulation;
-        uint32_t component = ShaderInterfaceVariableInfo::kInvalid;
-        if (varyingReg.registerColumn > 0)
+        if (varying.frontVarying.varying)
         {
-            ASSERT(!varying.varying->isStruct());
-            ASSERT(!gl::IsMatrixType(varying.varying->type));
-            component = varyingReg.registerColumn;
+            const std::string &name = varying.isStructField()
+                                          ? varying.frontVarying.parentStructMappedName
+                                          : varying.frontVarying.varying->mappedName;
+            AddLocationInfo(variableInfoMapOut, name, location, component,
+                            varying.frontVarying.stage);
+        }
+        if (varying.backVarying.varying)
+        {
+            const std::string &name = varying.isStructField()
+                                          ? varying.backVarying.parentStructMappedName
+                                          : varying.backVarying.varying->mappedName;
+            AddLocationInfo(variableInfoMapOut, name, location, component,
+                            varying.backVarying.stage);
         }
-
-        AddLocationInfo(variableInfoMapOut, name, location, component, varying.shaderStages);
     }
 
     // Add an entry for inactive varyings.
-    for (const std::string &varyingName : resources.varyingPacking.getInactiveVaryingMappedNames())
+    const gl::ShaderMap<std::vector<std::string>> &inactiveVaryingMappedNames =
+        resources.varyingPacking.getInactiveVaryingMappedNames();
+    for (const gl::ShaderType shaderType : programState.getLinkedShaderStages())
+    {
+        for (const std::string &varyingName : inactiveVaryingMappedNames[shaderType])
         {
             bool isBuiltin = angle::BeginsWith(varyingName, "gl_");
             if (isBuiltin)
@@ -612,17 +619,17 @@ void AssignVaryingLocations(const GlslangSourceOptions &options,
                 continue;
             }
 
-        // TODO(syoussefi): inactive varying names should be unique.  However, due to mishandling of
-        // partially captured arrays, a varying name can end up in both the active and inactive
-        // lists.  The test below should be removed once that issue is resolved.
-        // http://anglebug.com/4140
+            // If name is already in the map, it will automatically have marked all other stages
+            // inactive.
             if (variableInfoMapOut->find(varyingName) != variableInfoMapOut->end())
             {
                 continue;
             }
 
-        AddLocationInfo(variableInfoMapOut, varyingName, ShaderInterfaceVariableInfo::kInvalid,
-                        ShaderInterfaceVariableInfo::kInvalid, gl::ShaderBitSet());
+            // Otherwise, add an entry for it with all locations inactive.
+            ShaderInterfaceVariableInfo *info = &(*variableInfoMapOut)[varyingName];
+            ASSERT(info->location[shaderType] == ShaderInterfaceVariableInfo::kInvalid);
+        }
     }
 }
 
@@ -675,11 +682,8 @@ void AssignTransformFeedbackExtensionQualifiers(const gl::ProgramState &programS
 
             ASSERT(xfbVaryingLocation < locationsUsedForXfbExtension);
 
-            gl::ShaderBitSet vertexOnly;
-            vertexOnly.set(gl::ShaderType::Vertex);
-
             AddLocationInfo(variableInfoMapOut, xfbVaryingName, xfbVaryingLocation,
-                            ShaderInterfaceVariableInfo::kInvalid, vertexOnly);
+                            ShaderInterfaceVariableInfo::kInvalid, gl::ShaderType::Vertex);
             SetXfbInfo(variableInfoMapOut, xfbVaryingName, bufferIndex, currentOffset,
                        currentStride);
         }
@@ -703,7 +707,7 @@ void AssignTransformFeedbackExtensionQualifiers(const gl::ProgramState &programS
 
                 const gl::PackedVarying *varying = varyingReg.packedVarying;
 
-                if (varying->varying->name == tfVarying.name)
+                if (varying->frontVarying.varying->name == tfVarying.name)
                 {
                     originalVarying = varying;
                     break;
@@ -712,9 +716,10 @@ void AssignTransformFeedbackExtensionQualifiers(const gl::ProgramState &programS
 
             if (originalVarying)
             {
-                const std::string &mappedName = originalVarying->isStructField()
-                                                    ? originalVarying->parentStructMappedName
-                                                    : originalVarying->varying->mappedName;
+                const std::string &mappedName =
+                    originalVarying->isStructField()
+                        ? originalVarying->frontVarying.parentStructMappedName
+                        : originalVarying->frontVarying.varying->mappedName;
 
                 // Set xfb info for this varying.  AssignVaryingLocations should have already added
                 // location information for these varyings.

src/tests/gl_tests/GLSLTest.cpp

@@ -6166,9 +6166,6 @@ void main()
 // Test that linking varyings by location works.
 TEST_P(GLSLTest_ES31, LinkVaryingsByLocation)
 {
-    // http://anglebug.com/4355
-    ANGLE_SKIP_TEST_IF(IsVulkan() || IsMetal() || IsD3D11());
-
     constexpr char kVS[] = R"(#version 310 es
 precision highp float;
 in vec4 position;