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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Olli Etuaho
  Date : 2015-04-21 16:14:00
  Hash : 78174db7
  Message : 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>

• 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);
  }
  
  }