kc3-lang/angle/src/compiler/translator/RewriteElseBlocks.cpp

• Show log

  Commit

• Hash : 78174db7
  Author :
  Date : 2015-04-21T16:14:00
  

  Replace EvqInternal with a separate flag to make it more flexible
  
  The internal flag disables decorating a given symbol in output, effectively
  placing it to a different namespace than user-defined symbols. This enables the
  compiler to insert symbols to the tree when transforming it to be suitable for
  HLSL output without running into name conflicts. In this patch the flag is
  separated from the qualifiers since sometimes different qualifiers need to be
  used with these internal symbols.
  
  TEST=angle_unittests, angle_end2end_tests, WebGL conformance tests
  BUG=angleproject:941
  
  Change-Id: I7036bed98fdb1478a383bb959ca03b42c3cb8100
  Reviewed-on: https://chromium-review.googlesource.com/266690
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Zhenyao Mo <zmo@chromium.org>
  Tested-by: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/compiler/translator/RewriteElseBlocks.cpp

• //
  // Copyright (c) 2014 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.
  //
  // RewriteElseBlocks.cpp: Implementation for tree transform to change
  //   all if-else blocks to if-if blocks.
  //
  
  #include "compiler/translator/RewriteElseBlocks.h"
  #include "compiler/translator/NodeSearch.h"
  #include "compiler/translator/SymbolTable.h"
  
  namespace sh
  {
  
  namespace
  {
  
  class ElseBlockRewriter : public TIntermTraverser
  {
    public:
      ElseBlockRewriter();
  
    protected:
      bool visitAggregate(Visit visit, TIntermAggregate *aggregate);
  
    private:
      int mTemporaryIndex;
      const TType *mFunctionType;
  
      TIntermNode *rewriteSelection(TIntermSelection *selection);
  };
  
  TIntermSymbol *MakeNewTemporary(const TString &name, TBasicType type)
  {
      TType variableType(type, EbpHigh, EvqTemporary);
      TIntermSymbol *node = new TIntermSymbol(-1, name, variableType);
      node->setInternal(true);
      return node;
  }
  
  TIntermBinary *MakeNewBinary(TOperator op, TIntermTyped *left, TIntermTyped *right, const TType &resultType)
  {
      TIntermBinary *binary = new TIntermBinary(op);
      binary->setLeft(left);
      binary->setRight(right);
      binary->setType(resultType);
      return binary;
  }
  
  TIntermUnary *MakeNewUnary(TOperator op, TIntermTyped *operand)
  {
      TIntermUnary *unary = new TIntermUnary(op, operand->getType());
      unary->setOperand(operand);
      return unary;
  }
  
  ElseBlockRewriter::ElseBlockRewriter()
      : TIntermTraverser(true, false, true, false),
        mTemporaryIndex(0),
        mFunctionType(NULL)
  {}
  
  bool ElseBlockRewriter::visitAggregate(Visit visit, TIntermAggregate *node)
  {
      switch (node->getOp())
      {
        case EOpSequence:
          if (visit == PostVisit)
          {
              for (size_t statementIndex = 0; statementIndex != node->getSequence()->size(); statementIndex++)
              {
                  TIntermNode *statement = (*node->getSequence())[statementIndex];
                  TIntermSelection *selection = statement->getAsSelectionNode();
                  if (selection && selection->getFalseBlock() != NULL)
                  {
                      // Check for if / else if
                      TIntermSelection *elseIfBranch = selection->getFalseBlock()->getAsSelectionNode();
                      if (elseIfBranch)
                      {
                          selection->replaceChildNode(elseIfBranch, rewriteSelection(elseIfBranch));
                          delete elseIfBranch;
                      }
  
                      (*node->getSequence())[statementIndex] = rewriteSelection(selection);
                      delete selection;
                  }
              }
          }
          break;
  
        case EOpFunction:
          // Store the current function context (see comment below)
          mFunctionType = ((visit == PreVisit) ? &node->getType() : NULL);
          break;
  
        default: break;
      }
  
      return true;
  }
  
  TIntermNode *ElseBlockRewriter::rewriteSelection(TIntermSelection *selection)
  {
      ASSERT(selection != NULL);
  
      TString temporaryName = "cond_" + str(mTemporaryIndex++);
      TIntermTyped *typedCondition = selection->getCondition()->getAsTyped();
      TType resultType(EbtBool, EbpUndefined);
      TIntermSymbol *conditionSymbolInit = MakeNewTemporary(temporaryName, EbtBool);
      TIntermBinary *storeCondition = MakeNewBinary(EOpInitialize, conditionSymbolInit,
                                                    typedCondition, resultType);
      TIntermNode *negatedElse = NULL;
  
      TIntermSelection *falseBlock = NULL;
  
      if (selection->getFalseBlock())
      {
          // crbug.com/346463
          // D3D generates error messages claiming a function has no return value, when rewriting
          // an if-else clause that returns something non-void in a function. By appending dummy
          // returns (that are unreachable) we can silence this compile error.
          if (mFunctionType && mFunctionType->getBasicType() != EbtVoid)
          {
              TString typeString = mFunctionType->getStruct() ? mFunctionType->getStruct()->name() :
                  mFunctionType->getBasicString();
              TString rawText = "return (" + typeString + ")0";
              negatedElse = new TIntermRaw(*mFunctionType, rawText);
          }
  
          TIntermSymbol *conditionSymbolElse = MakeNewTemporary(temporaryName, EbtBool);
          TIntermUnary *negatedCondition = MakeNewUnary(EOpLogicalNot, conditionSymbolElse);
          falseBlock = new TIntermSelection(negatedCondition,
                                            selection->getFalseBlock(), negatedElse);
      }
  
      TIntermSymbol *conditionSymbolSel = MakeNewTemporary(temporaryName, EbtBool);
      TIntermSelection *newSelection = new TIntermSelection(conditionSymbolSel,
                                                            selection->getTrueBlock(), falseBlock);
  
      TIntermAggregate *declaration = new TIntermAggregate(EOpDeclaration);
      declaration->getSequence()->push_back(storeCondition);
  
      TIntermAggregate *block = new TIntermAggregate(EOpSequence);
      block->getSequence()->push_back(declaration);
      block->getSequence()->push_back(newSelection);
  
      return block;
  }
  
  }
  
  void RewriteElseBlocks(TIntermNode *node)
  {
      ElseBlockRewriter rewriter;
      node->traverse(&rewriter);
  }
  
  }
  

Download