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

• Show log

  Commit

• Hash : 6d40bbdd
  Author :
  Date : 2016-09-30T13:49:38
  

  Split TIntermBlock from TIntermAggregate
  
  The new TIntermBlock node class replaces TIntermAggregate nodes with
  the EOpSequence op. It represents the root node of the tree which is
  a list of declarations and function definitions, and any code blocks
  that can be denoted by curly braces. These include function and loop
  bodies, and if-else branches.
  
  This change enables a bunch of more compile-time type checking, and
  makes the AST code easier to understand and less error-prone.
  
  The PostProcess step that used to be done to ensure that the root node
  is TIntermAggregate is removed in favor of making sure that the root
  node is a TIntermBlock in the glslang.y parsing code.
  
  Intermediate output formatting is improved to print the EOpNull error
  in a clearer way.
  
  After this patch, TIntermAggregate is still used for function
  definitions, function prototypes, function parameter lists, function
  calls, variable and invariant declarations and the comma (sequence)
  operator.
  
  BUG=angleproject:1490
  TEST=angle_unittests, angle_end2end_tests
  
  Change-Id: I04044affff979a11577bc1fe75d747e538b799c8
  Reviewed-on: https://chromium-review.googlesource.com/393726
  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"
  
  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 &&
              !parentNode->getAsBlock())
          {
              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) &&
                  !parentNode->getAsBlock())
              {
                  return true;
              }
          }
      }
      return false;
  }
  
  bool IntermNodePatternMatcher::match(TIntermTernary *node)
  {
      if ((mMask & kUnfoldedShortCircuitExpression) != 0)
      {
          return true;
      }
      return false;
  }
  

Download