Translator: Collect gl_in as a varying.

include/GLSLANG/ShaderVars.h

@@ -51,10 +51,6 @@ enum class BlockType
 {
     BLOCK_UNIFORM,
     BLOCK_BUFFER,
-
-    // TODO: Remove gl_in from interface blocks and place it in varyings with the rest of shader I/O
-    // blocks, then remove GetInBlocks and getInBlocks everywhere.  http://anglebug.com/5423
-    BLOCK_IN
 };
 
 // Base class for all variables defined in shaders, including Varyings, Uniforms, etc

src/compiler/translator/BaseTypes.h

@@ -1097,6 +1097,8 @@ inline bool IsShaderIoBlock(TQualifier qualifier)
 {
     switch (qualifier)
     {
+        case EvqPerVertexIn:
+        case EvqPerVertexOut:
         case EvqVertexOut:
         case EvqTessControlIn:
         case EvqTessControlOut:

src/compiler/translator/CollectVariables.cpp

@@ -46,8 +46,6 @@ BlockType GetBlockType(TQualifier qualifier)
             return BlockType::BLOCK_UNIFORM;
         case EvqBuffer:
             return BlockType::BLOCK_BUFFER;
-        case EvqPerVertexIn:
-            return BlockType::BLOCK_IN;
         default:
             UNREACHABLE();
             return BlockType::BLOCK_UNIFORM;
@@ -123,7 +121,6 @@ class CollectVariablesTraverser : public TIntermTraverser
                               std::vector<ShaderVariable> *sharedVariables,
                               std::vector<InterfaceBlock> *uniformBlocks,
                               std::vector<InterfaceBlock> *shaderStorageBlocks,
-                              std::vector<InterfaceBlock> *inBlocks,
                               ShHashFunction64 hashFunction,
                               TSymbolTable *symbolTable,
                               GLenum shaderType,
@@ -166,7 +163,6 @@ class CollectVariablesTraverser : public TIntermTraverser
                                   std::vector<ShaderVariable> *varyings);
     void recordBuiltInFragmentOutputUsed(const TVariable &variable, bool *addedFlag);
     void recordBuiltInAttributeUsed(const TVariable &variable, bool *addedFlag);
-    InterfaceBlock *recordGLInUsed(const TType &glInType);
     InterfaceBlock *findNamedInterfaceBlock(const ImmutableString &name) const;
 
     std::vector<ShaderVariable> *mAttribs;
@@ -177,7 +173,6 @@ class CollectVariablesTraverser : public TIntermTraverser
     std::vector<ShaderVariable> *mSharedVariables;
     std::vector<InterfaceBlock> *mUniformBlocks;
     std::vector<InterfaceBlock> *mShaderStorageBlocks;
-    std::vector<InterfaceBlock> *mInBlocks;
 
     std::map<std::string, ShaderVariable *> mInterfaceBlockFields;
 
@@ -248,7 +243,6 @@ CollectVariablesTraverser::CollectVariablesTraverser(
     std::vector<sh::ShaderVariable> *sharedVariables,
     std::vector<sh::InterfaceBlock> *uniformBlocks,
     std::vector<sh::InterfaceBlock> *shaderStorageBlocks,
-    std::vector<sh::InterfaceBlock> *inBlocks,
     ShHashFunction64 hashFunction,
     TSymbolTable *symbolTable,
     GLenum shaderType,
@@ -262,7 +256,6 @@ CollectVariablesTraverser::CollectVariablesTraverser(
       mSharedVariables(sharedVariables),
       mUniformBlocks(uniformBlocks),
       mShaderStorageBlocks(shaderStorageBlocks),
-      mInBlocks(inBlocks),
       mDepthRangeAdded(false),
       mNumSamplesAdded(false),
       mNumWorkGroupsAdded(false),
@@ -317,7 +310,10 @@ void CollectVariablesTraverser::setBuiltInInfoFromSymbol(const TVariable &variab
     info->name       = variable.name().data();
     info->mappedName = variable.name().data();
 
-    setFieldOrVariableProperties(type, true, false, info);
+    bool isShaderIOBlock =
+        IsShaderIoBlock(type.getQualifier()) && type.getInterfaceBlock() != nullptr;
+
+    setFieldOrVariableProperties(type, true, isShaderIOBlock, info);
 }
 
 void CollectVariablesTraverser::recordBuiltInVaryingUsed(const TVariable &variable,
@@ -364,24 +360,6 @@ void CollectVariablesTraverser::recordBuiltInAttributeUsed(const TVariable &vari
     }
 }
 
-InterfaceBlock *CollectVariablesTraverser::recordGLInUsed(const TType &glInType)
-{
-    if (!mPerVertexInAdded)
-    {
-        ASSERT(glInType.getQualifier() == EvqPerVertexIn);
-        InterfaceBlock info;
-        recordInterfaceBlock("gl_in", glInType, &info);
-
-        mPerVertexInAdded = true;
-        mInBlocks->push_back(info);
-        return &mInBlocks->back();
-    }
-    else
-    {
-        return FindVariable(ImmutableString("gl_PerVertex"), mInBlocks);
-    }
-}
-
 bool CollectVariablesTraverser::visitGlobalQualifierDeclaration(
     Visit visit,
     TIntermGlobalQualifierDeclaration *node)
@@ -724,10 +702,8 @@ void CollectVariablesTraverser::setFieldOrVariableProperties(const TType &type,
             variableOut->fields.push_back(fieldVariable);
         }
     }
-    else if (interfaceBlock && interfaceBlock->symbolType() != SymbolType::BuiltIn)
+    else if (interfaceBlock && isShaderIOBlock)
     {
-        ASSERT(isShaderIOBlock);
-
         variableOut->type = GL_NONE;
         if (interfaceBlock->symbolType() != SymbolType::Empty)
         {
@@ -1119,31 +1095,28 @@ bool CollectVariablesTraverser::visitBinary(Visit, TIntermBinary *binaryNode)
 
         bool traverseIndexExpression         = false;
         TIntermBinary *interfaceIndexingNode = blockNode->getAsBinaryNode();
-        TIntermTyped *interfaceNode          = blockNode;
         if (interfaceIndexingNode)
         {
-            interfaceNode = interfaceIndexingNode->getLeft()->getAsTyped();
-            ASSERT(interfaceNode);
-
-            const TType &interfaceType = interfaceNode->getType();
-            if (interfaceType.getQualifier() == EvqPerVertexIn)
-            {
-                namedBlock = recordGLInUsed(interfaceType);
-                ASSERT(namedBlock);
-            }
-
-            // We need to continue traversing to collect useful variables in the index expression
-            // of the interface block array or gl_in in the case of the if above.
+            ASSERT(interfaceIndexingNode->getOp() == EOpIndexDirect ||
+                   interfaceIndexingNode->getOp() == EOpIndexIndirect);
             traverseIndexExpression = true;
+            blockNode               = interfaceIndexingNode->getLeft();
         }
 
-        const TType &interfaceNodeType        = interfaceNode->getType();
+        const TType &interfaceNodeType        = blockNode->getType();
         const TInterfaceBlock *interfaceBlock = interfaceNodeType.getInterfaceBlock();
         const TQualifier qualifier            = interfaceNodeType.getQualifier();
 
         // If it's a shader I/O block, look in varyings
         ShaderVariable *ioBlockVar = nullptr;
-        if (IsVaryingIn(qualifier))
+        if (qualifier == EvqPerVertexIn)
+        {
+            TIntermSymbol *symbolNode = blockNode->getAsSymbolNode();
+            ASSERT(symbolNode);
+            recordBuiltInVaryingUsed(symbolNode->variable(), &mPerVertexInAdded, mInputVaryings);
+            ioBlockVar = FindShaderIOBlockVariable(interfaceBlock->name(), mInputVaryings);
+        }
+        else if (IsVaryingIn(qualifier))
         {
             ioBlockVar = FindShaderIOBlockVariable(interfaceBlock->name(), mInputVaryings);
         }
@@ -1196,7 +1169,6 @@ void CollectVariables(TIntermBlock *root,
                       std::vector<ShaderVariable> *sharedVariables,
                       std::vector<InterfaceBlock> *uniformBlocks,
                       std::vector<InterfaceBlock> *shaderStorageBlocks,
-                      std::vector<InterfaceBlock> *inBlocks,
                       ShHashFunction64 hashFunction,
                       TSymbolTable *symbolTable,
                       GLenum shaderType,
@@ -1204,8 +1176,8 @@ void CollectVariables(TIntermBlock *root,
 {
     CollectVariablesTraverser collect(attributes, outputVariables, uniforms, inputVaryings,
                                       outputVaryings, sharedVariables, uniformBlocks,
-                                      shaderStorageBlocks, inBlocks, hashFunction, symbolTable,
-                                      shaderType, extensionBehavior);
+                                      shaderStorageBlocks, hashFunction, symbolTable, shaderType,
+                                      extensionBehavior);
     root->traverse(&collect);
 }
 

src/compiler/translator/CollectVariables.h

@@ -27,7 +27,6 @@ void CollectVariables(TIntermBlock *root,
                       std::vector<ShaderVariable> *sharedVariables,
                       std::vector<InterfaceBlock> *uniformBlocks,
                       std::vector<InterfaceBlock> *shaderStorageBlocks,
-                      std::vector<InterfaceBlock> *inBlocks,
                       ShHashFunction64 hashFunction,
                       TSymbolTable *symbolTable,
                       GLenum shaderType,

src/compiler/translator/Compiler.cpp

@@ -806,8 +806,8 @@ bool TCompiler::checkAndSimplifyAST(TIntermBlock *root,
         ASSERT(!mVariablesCollected);
         CollectVariables(root, &mAttributes, &mOutputVariables, &mUniforms, &mInputVaryings,
                          &mOutputVaryings, &mSharedVariables, &mUniformBlocks,
-                         &mShaderStorageBlocks, &mInBlocks, mResources.HashFunction, &mSymbolTable,
-                         mShaderType, mExtensionBehavior);
+                         &mShaderStorageBlocks, mResources.HashFunction, &mSymbolTable, mShaderType,
+                         mExtensionBehavior);
         collectInterfaceBlocks();
         mVariablesCollected = true;
         if (compileOptions & SH_USE_UNUSED_STANDARD_SHARED_BLOCKS)
@@ -1156,12 +1156,10 @@ void TCompiler::setResourceString()
 void TCompiler::collectInterfaceBlocks()
 {
     ASSERT(mInterfaceBlocks.empty());
-    mInterfaceBlocks.reserve(mUniformBlocks.size() + mShaderStorageBlocks.size() +
-                             mInBlocks.size());
+    mInterfaceBlocks.reserve(mUniformBlocks.size() + mShaderStorageBlocks.size());
     mInterfaceBlocks.insert(mInterfaceBlocks.end(), mUniformBlocks.begin(), mUniformBlocks.end());
     mInterfaceBlocks.insert(mInterfaceBlocks.end(), mShaderStorageBlocks.begin(),
                             mShaderStorageBlocks.end());
-    mInterfaceBlocks.insert(mInterfaceBlocks.end(), mInBlocks.begin(), mInBlocks.end());
 }
 
 bool TCompiler::emulatePrecisionIfNeeded(TIntermBlock *root,
@@ -1201,7 +1199,6 @@ void TCompiler::clearResults()
     mInterfaceBlocks.clear();
     mUniformBlocks.clear();
     mShaderStorageBlocks.clear();
-    mInBlocks.clear();
     mVariablesCollected    = false;
     mGLPositionInitialized = false;
 
@@ -1249,7 +1246,7 @@ bool TCompiler::checkCallDepth()
         int depth                     = 0;
         const CallDAG::Record &record = mCallDag.getRecordFromIndex(i);
 
-        for (const int &calleeIndex : record.callees)
+        for (int calleeIndex : record.callees)
         {
             depth = std::max(depth, depths[calleeIndex] + 1);
         }

src/compiler/translator/Compiler.h

@@ -123,7 +123,6 @@ class TCompiler : public TShHandleBase
     {
         return mShaderStorageBlocks;
     }
-    const std::vector<sh::InterfaceBlock> &getInBlocks() const { return mInBlocks; }
 
     ShHashFunction64 getHashFunction() const { return mResources.HashFunction; }
     NameMap &getNameMap() { return mNameMap; }
@@ -195,7 +194,6 @@ class TCompiler : public TShHandleBase
     std::vector<sh::InterfaceBlock> mInterfaceBlocks;
     std::vector<sh::InterfaceBlock> mUniformBlocks;
     std::vector<sh::InterfaceBlock> mShaderStorageBlocks;
-    std::vector<sh::InterfaceBlock> mInBlocks;
 
     // Specialization constant usage bits
     SpecConstUsageBits mSpecConstUsageBits;