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

• Show log

  Commit

• Hash : d0bad2c7
  Author :
  Date : 2016-09-09T18:01:16
  

  Split ternary node class from TIntermSelection
  
  Ternary operator nodes are typed parts of expressions, they always
  have two children and the children are also guaranteed to be
  TIntermTyped. "If" selection nodes can't be a part of an expression,
  they can have either one or two children and the children are code
  blocks. Due to all of these differences it makes sense to store these
  using two different AST node classes.
  
  BUG=angleproject:1490
  TEST=angle_unittests
  
  Change-Id: I913ab1d806e3cdb5c21106f078cc9c0b6c72ac54
  Reviewed-on: https://chromium-review.googlesource.com/384512
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/compiler/translator/IntermNodePatternMatcher.cpp

• //
  // Copyright (c) 2016 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.
  //
  // IntermNodePatternMatcher is a helper class for matching node trees to given patterns.
  // It can be used whenever the same checks for certain node structures are common to multiple AST
  // traversers.
  //
  
  #include "compiler/translator/IntermNodePatternMatcher.h"
  
  #include "compiler/translator/IntermNode.h"
  
  namespace
  {
  
  bool IsNodeBlock(TIntermNode *node)
  {
      ASSERT(node != nullptr);
      return (node->getAsAggregate() && node->getAsAggregate()->getOp() == EOpSequence);
  }
  
  }  // anonymous namespace
  
  IntermNodePatternMatcher::IntermNodePatternMatcher(const unsigned int mask) : mMask(mask)
  {
  }
  
  // static
  bool IntermNodePatternMatcher::IsDynamicIndexingOfVectorOrMatrix(TIntermBinary *node)
  {
      return node->getOp() == EOpIndexIndirect && !node->getLeft()->isArray() &&
             node->getLeft()->getBasicType() != EbtStruct;
  }
  
  bool IntermNodePatternMatcher::matchInternal(TIntermBinary *node, TIntermNode *parentNode)
  {
      if ((mMask & kExpressionReturningArray) != 0)
      {
          if (node->isArray() && node->getOp() == EOpAssign && parentNode != nullptr &&
              !IsNodeBlock(parentNode))
          {
              return true;
          }
      }
  
      if ((mMask & kUnfoldedShortCircuitExpression) != 0)
      {
          if (node->getRight()->hasSideEffects() &&
              (node->getOp() == EOpLogicalOr || node->getOp() == EOpLogicalAnd))
          {
              return true;
          }
      }
      return false;
  }
  
  bool IntermNodePatternMatcher::match(TIntermBinary *node, TIntermNode *parentNode)
  {
      // L-value tracking information is needed to check for dynamic indexing in L-value.
      // Traversers that don't track l-values can still use this class and match binary nodes with
      // this variation of this method if they don't need to check for dynamic indexing in l-values.
      ASSERT((mMask & kDynamicIndexingOfVectorOrMatrixInLValue) == 0);
      return matchInternal(node, parentNode);
  }
  
  bool IntermNodePatternMatcher::match(TIntermBinary *node,
                                       TIntermNode *parentNode,
                                       bool isLValueRequiredHere)
  {
      if (matchInternal(node, parentNode))
      {
          return true;
      }
      if ((mMask & kDynamicIndexingOfVectorOrMatrixInLValue) != 0)
      {
          if (isLValueRequiredHere && IsDynamicIndexingOfVectorOrMatrix(node))
          {
              return true;
          }
      }
      return false;
  }
  
  bool IntermNodePatternMatcher::match(TIntermAggregate *node, TIntermNode *parentNode)
  {
      if ((mMask & kExpressionReturningArray) != 0)
      {
          if (parentNode != nullptr)
          {
              TIntermBinary *parentBinary = parentNode->getAsBinaryNode();
              bool parentIsAssignment =
                  (parentBinary != nullptr &&
                   (parentBinary->getOp() == EOpAssign || parentBinary->getOp() == EOpInitialize));
  
              if (node->getType().isArray() && !parentIsAssignment &&
                  (node->isConstructor() || node->getOp() == EOpFunctionCall) &&
                  !IsNodeBlock(parentNode))
              {
                  return true;
              }
          }
      }
      return false;
  }
  
  bool IntermNodePatternMatcher::match(TIntermTernary *node)
  {
      if ((mMask & kUnfoldedShortCircuitExpression) != 0)
      {
          return true;
      }
      return false;
  }
  

Download