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

• Show log

  Commit

• Hash : 3272a6d3
  Author :
  Date : 2016-08-29T17:54:50
  

  Promote and fold indexing nodes similarly to other binary ops
  
  Indexing nodes now get their type set in TIntermBinary::promote, same
  as math and logic ops. They are also constant folded through
  TIntermBinary::fold() instead of having special functions for constant
  folding them in ParseContext.
  
  Index nodes for struct and interface block member access now always
  have integer type, instead of sometimes having the type of the field
  they were used to access.
  
  Usage of TIntermBinary constructor is cleaned up so only the
  constructor that takes in left and right operands is used. The type
  of TIntermBinary nodes is always determined automatically.
  
  Together these changes make the code considerably cleaner.
  
  Note that the code for constant folding for array indexing is actually
  never hit because constant folding array constructors is still
  intentionally disabled in the code.
  
  BUG=angleproject:1490
  TEST=angle_unittests
  
  Change-Id: Ifcec45257476cdb0d495c7d72e3cf2f83388e8c5
  Reviewed-on: https://chromium-review.googlesource.com/377961
  Reviewed-by: Jamie Madill <jmadill@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
  {
  
  class SeparateArrayInitTraverser : private TIntermTraverser
  {
    public:
      static void apply(TIntermNode *root);
    private:
      SeparateArrayInitTraverser();
      bool visitAggregate(Visit, TIntermAggregate *node) override;
  };
  
  void SeparateArrayInitTraverser::apply(TIntermNode *root)
  {
      SeparateArrayInitTraverser separateInit;
      root->traverse(&separateInit);
      separateInit.updateTree();
  }
  
  SeparateArrayInitTraverser::SeparateArrayInitTraverser()
      : TIntermTraverser(true, false, false)
  {
  }
  
  bool SeparateArrayInitTraverser::visitAggregate(Visit, TIntermAggregate *node)
  {
      if (node->getOp() == EOpDeclaration)
      {
          TIntermSequence *sequence = node->getSequence();
          TIntermBinary *initNode = sequence->back()->getAsBinaryNode();
          if (initNode != nullptr && initNode->getOp() == EOpInitialize)
          {
              TIntermTyped *initializer = initNode->getRight();
              if (initializer->isArray() && !sh::OutputHLSL::canWriteAsHLSLLiteral(initializer))
              {
                  // We rely on that array declarations have been isolated to single declarations.
                  ASSERT(sequence->size() == 1);
                  TIntermTyped *symbol = initNode->getLeft();
                  TIntermAggregate *parentAgg = getParentNode()->getAsAggregate();
                  ASSERT(parentAgg != nullptr);
  
                  TIntermSequence replacements;
  
                  TIntermAggregate *replacementDeclaration = new TIntermAggregate;
                  replacementDeclaration->setOp(EOpDeclaration);
                  replacementDeclaration->getSequence()->push_back(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(parentAgg, node, replacements));
              }
          }
          return false;
      }
      return true;
  }
  
  } // namespace
  
  void SeparateArrayInitialization(TIntermNode *root)
  {
      SeparateArrayInitTraverser::apply(root);
  }
  

Download