kc3-lang/angle/src/compiler/translator/tree_util/RunAtTheEndOfShader.cpp

• Show log

  Commit

• Hash : 8dc9e83e
  Author :
  Date : 2022-02-16T21:48:53
  

  Translator: Fix RunAtTheEndOfShader w.r.t discard
  
  RunAtTheEndOfShader wrapped main() if it ended in discard.  However, it
  didn't account for the fact that the discard instruction could be
  wrapped in a block.  This change makes RunAtTheEndOfShader more
  conservative w.r.t discard and has it wrap main() on any encounter of
  discard.
  
  The change additionally adds AST validation to ensure transformations
  don't generate dead code after branches.
  
  Test credit to Cody Northrop.
  
  Test: GLSLTest_ES3.ConstantConditionGuardingDiscard
  Test: GLSLTest_ES3.NestedUnconditionalDiscards
  Bug: angleproject:7033
  Change-Id: Ie9d5210a5cfbb13449720a8a3f44666df9443d98
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3471014
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/compiler/translator/tree_util/RunAtTheEndOfShader.cpp

• //
  // 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.
  //
  // RunAtTheEndOfShader.cpp: Add code to be run at the end of the shader. In case main() contains a
  // return statement, this is done by replacing the main() function with another function that calls
  // the old main, like this:
  //
  // void main() { body }
  // =>
  // void main0() { body }
  // void main()
  // {
  //     main0();
  //     codeToRun
  // }
  //
  // This way the code will get run even if the return statement inside main is executed.
  //
  // This is done if main ends in an unconditional |discard| as well, to help with SPIR-V generation
  // that expects no dead-code to be present after branches in a block.  To avoid bugs when |discard|
  // is wrapped in unconditional blocks, any |discard| in main() is used as a signal to wrap it.
  //
  
  #include "compiler/translator/tree_util/RunAtTheEndOfShader.h"
  
  #include "compiler/translator/Compiler.h"
  #include "compiler/translator/IntermNode.h"
  #include "compiler/translator/StaticType.h"
  #include "compiler/translator/SymbolTable.h"
  #include "compiler/translator/tree_util/FindMain.h"
  #include "compiler/translator/tree_util/IntermNode_util.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  
  namespace sh
  {
  
  namespace
  {
  
  constexpr const ImmutableString kMainString("main");
  
  class ContainsReturnOrDiscardTraverser : public TIntermTraverser
  {
    public:
      ContainsReturnOrDiscardTraverser()
          : TIntermTraverser(true, false, false), mContainsReturnOrDiscard(false)
      {}
  
      bool visitBranch(Visit visit, TIntermBranch *node) override
      {
          if (node->getFlowOp() == EOpReturn || node->getFlowOp() == EOpKill)
          {
              mContainsReturnOrDiscard = true;
          }
          return false;
      }
  
      bool containsReturnOrDiscard() { return mContainsReturnOrDiscard; }
  
    private:
      bool mContainsReturnOrDiscard;
  };
  
  bool ContainsReturnOrDiscard(TIntermNode *node)
  {
      ContainsReturnOrDiscardTraverser traverser;
      node->traverse(&traverser);
      return traverser.containsReturnOrDiscard();
  }
  
  void WrapMainAndAppend(TIntermBlock *root,
                         TIntermFunctionDefinition *main,
                         TIntermNode *codeToRun,
                         TSymbolTable *symbolTable)
  {
      // Replace main() with main0() with the same body.
      TFunction *oldMain =
          new TFunction(symbolTable, kEmptyImmutableString, SymbolType::AngleInternal,
                        StaticType::GetBasic<EbtVoid, EbpUndefined>(), false);
      TIntermFunctionDefinition *oldMainDefinition =
          CreateInternalFunctionDefinitionNode(*oldMain, main->getBody());
  
      bool replaced = root->replaceChildNode(main, oldMainDefinition);
      ASSERT(replaced);
  
      // void main()
      TFunction *newMain = new TFunction(symbolTable, kMainString, SymbolType::UserDefined,
                                         StaticType::GetBasic<EbtVoid, EbpUndefined>(), false);
      TIntermFunctionPrototype *newMainProto = new TIntermFunctionPrototype(newMain);
  
      // {
      //     main0();
      //     codeToRun
      // }
      TIntermBlock *newMainBody = new TIntermBlock();
      TIntermSequence emptySequence;
      TIntermAggregate *oldMainCall = TIntermAggregate::CreateFunctionCall(*oldMain, &emptySequence);
      newMainBody->appendStatement(oldMainCall);
      newMainBody->appendStatement(codeToRun);
  
      // Add the new main() to the root node.
      TIntermFunctionDefinition *newMainDefinition =
          new TIntermFunctionDefinition(newMainProto, newMainBody);
      root->appendStatement(newMainDefinition);
  }
  
  }  // anonymous namespace
  
  bool RunAtTheEndOfShader(TCompiler *compiler,
                           TIntermBlock *root,
                           TIntermNode *codeToRun,
                           TSymbolTable *symbolTable)
  {
      TIntermFunctionDefinition *main = FindMain(root);
      if (ContainsReturnOrDiscard(main))
      {
          WrapMainAndAppend(root, main, codeToRun, symbolTable);
      }
      else
      {
          main->getBody()->appendStatement(codeToRun);
      }
  
      return compiler->validateAST(root);
  }
  
  }  // namespace sh
  

Download