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

• Show log

  Commit

• Hash : b1edc4f5
  Author :
  Date : 2015-11-02T17:20:03
  

  Accept const array initialization in shader parsing
  
  Array constructors are not folded, unlike all other constant expressions.
  Change initializer parsing path so that it accepts constant initializers
  whether they are folded or not.
  
  Some parts need to be adapted to work with expressions that are qualified
  as constant but that are not necessarily folded:
  
  1. Identifier parsing
  2. Indexing parsing
  3. Field selection parsing
  4. HLSL output for variable declarations
  5. Determining unary operator result type
  6. Determining binary operator result type
  7. Determining built-in function call result type
  8. Determining ternary operator result type
  
  Corner cases that are not supported yet:
  
  1. Using array constructors inside case labels
  2. Using array constructors inside array size expressions
  3. Detecting when a negative constant expression containing an array
     constructor is used to index an array
  
  In these cases being able to constant fold the expression is essential to
  validating that the code is correct, so they require a more sophisticated
  solution. For now we keep the old code that rejects the shader if ANGLE
  hasn't been able to constant fold the case label or array size. In case of
  indexing an array with a negative constant expression containing an array
  constructor, ANGLE will simply treat it as a non-constant expression.
  
  BUG=541551
  BUG=angleproject:1094
  TEST=dEQP-GLES3.functional.shaders.constant_expressions.* (all pass),
       angle_unittests
  
  Change-Id: I0cbc47afd1651a4dece3d68acf7ec72a01fdf047
  Reviewed-on: https://chromium-review.googlesource.com/310231
  Tested-by: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Jamie Madill <jmadill@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 is still split, making the AST
  // technically invalid. Because of that this transformation should only be used when subsequent
  // stages don't care about const qualifiers.
  
  #include "compiler/translator/SeparateArrayInitialization.h"
  
  #include "compiler/translator/IntermNode.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())
              {
                  // 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);
                  replacementAssignment->setLeft(symbol);
                  replacementAssignment->setRight(initializer);
                  replacementAssignment->setType(initializer->getType());
                  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