kc3-lang/angle/src/compiler/translator/tree_ops/RemoveInactiveInterfaceVariables.cpp

• Show log

  Commit

• Hash : d7aa0130
  Author :
  Date : 2021-04-26T16:56:15
  

  Upstream Apple's direct-to-Metal backend: compile translator.
  
  This change is meant to merge the translator changes from Apple's
  direct-to-Metal backend. Taken from Kyle Piddington's CL:
  https://chromium-review.googlesource.com/c/angle/angle/+/2857366/
  The goal of this CL is to merge the translator code in a state that
  compiles, but not to switch the Metal backend over to use this
  translator backend yet.
  
  Bug: angleproject:5505
  Change-Id: I68a6354604498cd5fd1eb96c13fc56f3b38f2bd0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2897536
  Reviewed-by: Jonah Ryan-Davis <jonahr@google.com>
  Commit-Queue: Jonah Ryan-Davis <jonahr@google.com>
  

Download

• src/compiler/translator/tree_ops/RemoveInactiveInterfaceVariables.cpp

• //
  // Copyright 2019 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.
  //
  // RemoveInactiveInterfaceVariables.h:
  //  Drop shader interface variable declarations for those that are inactive.
  //
  
  #include "compiler/translator/tree_ops/RemoveInactiveInterfaceVariables.h"
  
  #include "compiler/translator/SymbolTable.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  #include "compiler/translator/util.h"
  
  namespace sh
  {
  
  namespace
  {
  
  // Traverser that removes all declarations that correspond to inactive variables.
  class RemoveInactiveInterfaceVariablesTraverser : public TIntermTraverser
  {
    public:
      RemoveInactiveInterfaceVariablesTraverser(
          TSymbolTable *symbolTable,
          const std::vector<sh::ShaderVariable> &attributes,
          const std::vector<sh::ShaderVariable> &inputVaryings,
          const std::vector<sh::ShaderVariable> &outputVariables,
          const std::vector<sh::ShaderVariable> &uniforms,
          const std::vector<sh::InterfaceBlock> &interfaceBlocks);
  
      bool visitDeclaration(Visit visit, TIntermDeclaration *node) override;
  
    private:
      const std::vector<sh::ShaderVariable> &mAttributes;
      const std::vector<sh::ShaderVariable> &mInputVaryings;
      const std::vector<sh::ShaderVariable> &mOutputVariables;
      const std::vector<sh::ShaderVariable> &mUniforms;
      const std::vector<sh::InterfaceBlock> &mInterfaceBlocks;
  };
  
  RemoveInactiveInterfaceVariablesTraverser::RemoveInactiveInterfaceVariablesTraverser(
      TSymbolTable *symbolTable,
      const std::vector<sh::ShaderVariable> &attributes,
      const std::vector<sh::ShaderVariable> &inputVaryings,
      const std::vector<sh::ShaderVariable> &outputVariables,
      const std::vector<sh::ShaderVariable> &uniforms,
      const std::vector<sh::InterfaceBlock> &interfaceBlocks)
      : TIntermTraverser(true, false, false, symbolTable),
        mAttributes(attributes),
        mInputVaryings(inputVaryings),
        mOutputVariables(outputVariables),
        mUniforms(uniforms),
        mInterfaceBlocks(interfaceBlocks)
  {}
  
  template <typename Variable>
  bool IsVariableActive(const std::vector<Variable> &mVars, const ImmutableString &name)
  {
      for (const Variable &var : mVars)
      {
          if (name == var.name)
          {
              return var.active;
          }
      }
      UNREACHABLE();
      return true;
  }
  
  bool RemoveInactiveInterfaceVariablesTraverser::visitDeclaration(Visit visit,
                                                                   TIntermDeclaration *node)
  {
      // SeparateDeclarations should have already been run.
      ASSERT(node->getSequence()->size() == 1u);
  
      TIntermTyped *declarator = node->getSequence()->front()->getAsTyped();
      ASSERT(declarator);
  
      TIntermSymbol *asSymbol = declarator->getAsSymbolNode();
      if (!asSymbol)
      {
          return false;
      }
  
      const TType &type = declarator->getType();
  
      // Remove all shader interface variables except outputs, i.e. uniforms, interface blocks and
      // inputs.
      //
      // Imagine a situation where the VS doesn't write to a varying but the FS reads from it.  This
      // is allowed, though the value of the varying is undefined.  If the varying is removed here,
      // the situation is changed to VS not declaring the varying, but the FS reading from it, which
      // is not allowed.  That's why inactive shader outputs are not removed.
      //
      // Inactive fragment shader outputs can be removed though, as there is no next stage.
      bool removeDeclaration     = false;
      const TQualifier qualifier = type.getQualifier();
  
      if (type.isInterfaceBlock())
      {
          // When a member has an explicit location, interface block should not be removed.
          // If the member or interface would be removed, GetProgramResource could not return the
          // location.
          if (!IsShaderIoBlock(type.getQualifier()) && type.getQualifier() != EvqPatchIn &&
              type.getQualifier() != EvqPatchOut)
          {
              removeDeclaration =
                  !IsVariableActive(mInterfaceBlocks, type.getInterfaceBlock()->name());
          }
      }
      else if (qualifier == EvqUniform)
      {
          removeDeclaration = !IsVariableActive(mUniforms, asSymbol->getName());
      }
      else if (qualifier == EvqAttribute || qualifier == EvqVertexIn)
      {
          removeDeclaration = !IsVariableActive(mAttributes, asSymbol->getName());
      }
      else if (IsShaderIn(qualifier))
      {
          removeDeclaration = !IsVariableActive(mInputVaryings, asSymbol->getName());
      }
      else if (qualifier == EvqFragmentOut)
      {
          removeDeclaration = !IsVariableActive(mOutputVariables, asSymbol->getName());
      }
  
      if (removeDeclaration)
      {
          TIntermSequence replacement;
  
          // If the declaration was of a struct, keep the struct declaration itself.
          if (type.isStructSpecifier())
          {
              TType *structSpecifierType      = new TType(type.getStruct(), true);
              TVariable *emptyVariable        = new TVariable(mSymbolTable, kEmptyImmutableString,
                                                       structSpecifierType, SymbolType::Empty);
              TIntermDeclaration *declaration = new TIntermDeclaration();
              declaration->appendDeclarator(new TIntermSymbol(emptyVariable));
              replacement.push_back(declaration);
          }
  
          mMultiReplacements.emplace_back(getParentNode()->getAsBlock(), node,
                                          std::move(replacement));
      }
  
      return false;
  }
  
  }  // namespace
  
  bool RemoveInactiveInterfaceVariables(TCompiler *compiler,
                                        TIntermBlock *root,
                                        TSymbolTable *symbolTable,
                                        const std::vector<sh::ShaderVariable> &attributes,
                                        const std::vector<sh::ShaderVariable> &inputVaryings,
                                        const std::vector<sh::ShaderVariable> &outputVariables,
                                        const std::vector<sh::ShaderVariable> &uniforms,
                                        const std::vector<sh::InterfaceBlock> &interfaceBlocks)
  {
      RemoveInactiveInterfaceVariablesTraverser traverser(symbolTable, attributes, inputVaryings,
                                                          outputVariables, uniforms, interfaceBlocks);
      root->traverse(&traverser);
      return traverser.updateTree(compiler, root);
  }
  
  }  // namespace sh
  

Download