kc3-lang/angle/src/tests/test_utils/ConstantFoldingTest.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/tests/test_utils/ConstantFoldingTest.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.
  //
  // ConstantFoldingTest.cpp:
  //   Utilities for constant folding tests.
  //
  
  #include "tests/test_utils/ConstantFoldingTest.h"
  
  #include "angle_gl.h"
  #include "compiler/translator/TranslatorESSL.h"
  #include "GLSLANG/ShaderLang.h"
  
  using namespace sh;
  
  void ConstantFoldingExpressionTest::evaluateFloat(const std::string &floatExpression)
  {
      // We first assign the expression into a const variable so we can also verify that it gets
      // qualified as a constant expression. We then assign that constant expression into my_FragColor
      // to make sure that the value is not pruned.
      std::stringstream shaderStream;
      shaderStream << "#version 310 es\n"
                      "precision mediump float;\n"
                      "out float my_FragColor;\n"
                      "void main()\n"
                      "{\n"
                   << "    const float f = " << floatExpression << ";\n"
                   << "    my_FragColor = f;\n"
                      "}\n";
      compileAssumeSuccess(shaderStream.str());
  }
  
  void ConstantFoldingExpressionTest::evaluateInt(const std::string &intExpression)
  {
      // We first assign the expression into a const variable so we can also verify that it gets
      // qualified as a constant expression. We then assign that constant expression into my_FragColor
      // to make sure that the value is not pruned.
      std::stringstream shaderStream;
      shaderStream << "#version 310 es\n"
                      "precision mediump int;\n"
                      "out int my_FragColor;\n"
                      "void main()\n"
                      "{\n"
                   << "    const int i = " << intExpression << ";\n"
                   << "    my_FragColor = i;\n"
                      "}\n";
      compileAssumeSuccess(shaderStream.str());
  }
  
  void ConstantFoldingExpressionTest::evaluateUint(const std::string &uintExpression)
  {
      // We first assign the expression into a const variable so we can also verify that it gets
      // qualified as a constant expression. We then assign that constant expression into my_FragColor
      // to make sure that the value is not pruned.
      std::stringstream shaderStream;
      shaderStream << "#version 310 es\n"
                      "precision mediump int;\n"
                      "out uint my_FragColor;\n"
                      "void main()\n"
                      "{\n"
                   << "    const uint u = " << uintExpression << ";\n"
                   << "    my_FragColor = u;\n"
                      "}\n";
      compileAssumeSuccess(shaderStream.str());
  }
  

Download