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

• Show log

  Commit

• Hash : ea22b7a5
  Author :
  Date : 2018-01-04T17:09:11
  

  Constant fold array indexing and comparison
  
  A virtual function to get the constant value of an AST node is added
  to TIntermTyped. This way a constant value can be retrieved
  conveniently from multiple different types of nodes. TIntermSymbol
  nodes pointing to a const variable can return the value associated
  with the variable, constructor nodes can build a constant value from
  their arguments, and indexing nodes can index into a constant array.
  
  This enables constant folding operations on constant arrays, while
  making sure that large amounts of data are not duplicated in the
  output shader. When folding an operation makes sense, the values of
  the arguments can be retrieved by using the new
  TIntermTyped::getConstantValue(). When folding an operation would
  result in duplicating data, the AST can just be left to be written out
  as is.
  
  For example, if the code contains a constant array of arrays, indexing
  into individual elements of the inner arrays can be folded, but
  indexing the top level array is left in place and not replaced with
  duplicated array literals.
  
  Constant folding is supported for indexing and comparisons of arrays.
  
  In case constant arrays are only referenced through foldable
  operations, the variable declarations will be pruned from the AST by
  the RemoveUnreferencedVariables step.
  
  BUG=angleproject:2298
  TEST=angle_unittests
  
  Change-Id: I5b3be237b7e9fdba56aa9bf0a41b691f4d8f01eb
  Reviewed-on: https://chromium-review.googlesource.com/850973
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/compiler/translator/SeparateArrayInitialization.cpp

• //
  // Copyright (c) 2002-2015 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.
  //
  // The SeparateArrayInitialization function splits each array initialization into a declaration and
  // an assignment.
  // Example:
  //     type[n] a = initializer;
  // will effectively become
  //     type[n] a;
  //     a = initializer;
  //
  // Note that if the array is declared as const, the initialization may still be split, making the
  // AST technically invalid. Because of that this transformation should only be used when subsequent
  // stages don't care about const qualifiers. However, the initialization will not be split if the
  // initializer can be written as a HLSL literal.
  
  #include "compiler/translator/SeparateArrayInitialization.h"
  
  #include "compiler/translator/IntermNode.h"
  #include "compiler/translator/OutputHLSL.h"
  
  namespace sh
  {
  
  namespace
  {
  
  class SeparateArrayInitTraverser : private TIntermTraverser
  {
    public:
      static void apply(TIntermNode *root);
  
    private:
      SeparateArrayInitTraverser();
      bool visitDeclaration(Visit, TIntermDeclaration *node) override;
  };
  
  void SeparateArrayInitTraverser::apply(TIntermNode *root)
  {
      SeparateArrayInitTraverser separateInit;
      root->traverse(&separateInit);
      separateInit.updateTree();
  }
  
  SeparateArrayInitTraverser::SeparateArrayInitTraverser() : TIntermTraverser(true, false, false)
  {
  }
  
  bool SeparateArrayInitTraverser::visitDeclaration(Visit, TIntermDeclaration *node)
  {
      TIntermSequence *sequence = node->getSequence();
      TIntermBinary *initNode   = sequence->back()->getAsBinaryNode();
      if (initNode != nullptr && initNode->getOp() == EOpInitialize)
      {
          TIntermTyped *initializer = initNode->getRight();
          if (initializer->isArray() && !initializer->hasConstantValue())
          {
              // We rely on that array declarations have been isolated to single declarations.
              ASSERT(sequence->size() == 1);
              TIntermTyped *symbol      = initNode->getLeft();
              TIntermBlock *parentBlock = getParentNode()->getAsBlock();
              ASSERT(parentBlock != nullptr);
  
              TIntermSequence replacements;
  
              TIntermDeclaration *replacementDeclaration = new TIntermDeclaration();
              replacementDeclaration->appendDeclarator(symbol);
              replacementDeclaration->setLine(symbol->getLine());
              replacements.push_back(replacementDeclaration);
  
              TIntermBinary *replacementAssignment =
                  new TIntermBinary(EOpAssign, symbol, initializer);
              replacementAssignment->setLine(symbol->getLine());
              replacements.push_back(replacementAssignment);
  
              mMultiReplacements.push_back(
                  NodeReplaceWithMultipleEntry(parentBlock, node, replacements));
          }
      }
      return false;
  }
  
  }  // namespace
  
  void SeparateArrayInitialization(TIntermNode *root)
  {
      SeparateArrayInitTraverser::apply(root);
  }
  
  }  // namespace sh
  

Download