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

• Show log

  Commit

• Hash : 13389b66
  Author :
  Date : 2016-10-16T11:48:18
  

  Split TIntermDeclaration from TIntermAggregate
  
  The new class TIntermDeclaration is now used for struct, interface
  block and variable declarations. TIntermDeclaration nodes do not have
  a type - rather the type is stored in each child node. The types may
  differ in case the declaration is a series of array declarators with
  mismatching sizes.
  
  TIntermAggregate is still used for function calls, function
  prototypes, function parameter lists and invariant declarations.
  
  BUG=angleproject:1490
  TEST=angle_unittests
  
  Change-Id: I0457188f354481470855f61ac1c878fc2579b1d1
  Reviewed-on: https://chromium-review.googlesource.com/400023
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

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 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() && !sh::OutputHLSL::canWriteAsHLSLLiteral(initializer))
          {
              // 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);
  }
  

Download