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

• Show log

  Commit

• Hash : a5dd3888
  Author :
  Date : 2019-12-04T14:31:57
  

  Vulkan: fix handling of inactive atomic counters
  
  The translator emulates atomic counters with a storage buffer array
  during translation to Vulkan GLSL.  Glslang wrapper then should assign
  set/binding to this buffer.  However, if the atomic counters are
  actually unused in the shader, this assignment is never done.
  
  This change adds a small tree transformation for Vulkan that removes any
  uniform or interface block declaration that's not active.  In
  particular, this makes atomic counter emulation a no-op if no atomic
  counters are used.  It also has the benefit of not requiring glslang
  wrapper to remove such inactive resources.
  
  Bug: angleproject:4190
  Change-Id: I286c199854ec2379558ad1ec48b4d2c4bf5544d0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1951523
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Courtney Goeltzenleuchter <courtneygo@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(
          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> &mUniforms;
      const std::vector<sh::InterfaceBlock> &mInterfaceBlocks;
  };
  
  RemoveInactiveInterfaceVariablesTraverser::RemoveInactiveInterfaceVariablesTraverser(
      const std::vector<sh::ShaderVariable> &uniforms,
      const std::vector<sh::InterfaceBlock> &interfaceBlocks)
      : TIntermTraverser(true, false, false), 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();
  
      // Only remove opaque uniform and interface block declarations.
      //
      // Note: Don't remove varyings.  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.
      bool removeDeclaration = false;
  
      if (type.isInterfaceBlock())
      {
          removeDeclaration = !isVariableActive(mInterfaceBlocks, type.getInterfaceBlock()->name());
      }
      else if (type.getQualifier() == EvqUniform && IsOpaqueType(type.getBasicType()))
      {
          removeDeclaration = !isVariableActive(mUniforms, asSymbol->getName());
      }
  
      if (removeDeclaration)
      {
          TIntermSequence emptySequence;
          mMultiReplacements.emplace_back(getParentNode()->getAsBlock(), node, emptySequence);
      }
  
      return false;
  }
  
  }  // namespace
  
  bool RemoveInactiveInterfaceVariables(TCompiler *compiler,
                                        TIntermBlock *root,
                                        const std::vector<sh::ShaderVariable> &uniforms,
                                        const std::vector<sh::InterfaceBlock> &interfaceBlocks)
  {
      RemoveInactiveInterfaceVariablesTraverser traverser(uniforms, interfaceBlocks);
      root->traverse(&traverser);
      return traverser.updateTree(compiler, root);
  }
  
  }  // namespace sh
  

Download