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

• Show log

  Commit

• Hash : fab397e5
  Author :
  Date : 2019-07-25T10:18:50
  

  Vulkan: Enforce an error when initializing a global with a non-const
  
  The ESSL 1.0 spec is clear that "initializers must be a constant expression."
  Yet, because of "legacy" applications (apparently just WebGL applications), the
  code was only issuing a warning and not an error.  The
  "KHR-GLES2.shaders.negative.initialize" test requires an error be generated.
  This change splits the semantics, allowing GLES applications to get an error,
  and WebGL applications to get a warning.
  
  Note: This change is related to https://chromium-review.googlesource.com/829138
  (for angleproject:2285).
  
  Bug: angleproject:3381
  Change-Id: Ie243b7dd72102aeb52df506d121d1d2a8f6974d3
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1716617
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Ian Elliott <ianelliott@google.com>
  

Download

• src/compiler/translator/ValidateGlobalInitializer.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.
  //
  
  #include "compiler/translator/ValidateGlobalInitializer.h"
  
  #include "compiler/translator/tree_util/IntermTraverse.h"
  
  namespace sh
  {
  
  namespace
  {
  
  const int kMaxAllowedTraversalDepth = 256;
  
  class ValidateGlobalInitializerTraverser : public TIntermTraverser
  {
    public:
      ValidateGlobalInitializerTraverser(int shaderVersion, bool isWebGL);
  
      void visitSymbol(TIntermSymbol *node) override;
      void visitConstantUnion(TIntermConstantUnion *node) override;
      bool visitAggregate(Visit visit, TIntermAggregate *node) override;
      bool visitBinary(Visit visit, TIntermBinary *node) override;
      bool visitUnary(Visit visit, TIntermUnary *node) override;
  
      bool isValid() const { return mIsValid && mMaxDepth < mMaxAllowedDepth; }
      bool issueWarning() const { return mIssueWarning; }
  
    private:
      int mShaderVersion;
      bool mIsWebGL;
      bool mIsValid;
      bool mIssueWarning;
  };
  
  void ValidateGlobalInitializerTraverser::visitSymbol(TIntermSymbol *node)
  {
      // ESSL 1.00 section 4.3 (or ESSL 3.00 section 4.3):
      // Global initializers must be constant expressions.
      switch (node->getType().getQualifier())
      {
          case EvqConst:
              break;
          case EvqGlobal:
          case EvqTemporary:
          case EvqUniform:
              // We allow these cases to be compatible with legacy ESSL 1.00 content.
              // Implement stricter rules for ESSL 3.00 since there's no legacy content to deal
              // with.
              if ((mShaderVersion >= 300) || !mIsWebGL)
              {
                  mIsValid = false;
              }
              else
              {
                  mIssueWarning = true;
              }
              break;
          default:
              mIsValid = false;
      }
  }
  
  void ValidateGlobalInitializerTraverser::visitConstantUnion(TIntermConstantUnion *node)
  {
      // Constant unions that are not constant expressions may result from folding a ternary
      // expression.
      switch (node->getType().getQualifier())
      {
          case EvqConst:
              break;
          case EvqTemporary:
              if ((mShaderVersion >= 300) || !mIsWebGL)
              {
                  mIsValid = false;
              }
              else
              {
                  mIssueWarning = true;
              }
              break;
          default:
              UNREACHABLE();
      }
  }
  
  bool ValidateGlobalInitializerTraverser::visitAggregate(Visit visit, TIntermAggregate *node)
  {
      // Disallow calls to user-defined functions and texture lookup functions in global variable
      // initializers.
      // This is done simply by disabling all function calls - built-in math functions don't use
      // the function call ops.
      if (node->isFunctionCall())
      {
          mIsValid = false;
      }
      return true;
  }
  
  bool ValidateGlobalInitializerTraverser::visitBinary(Visit visit, TIntermBinary *node)
  {
      if (node->isAssignment())
      {
          mIsValid = false;
      }
      return true;
  }
  
  bool ValidateGlobalInitializerTraverser::visitUnary(Visit visit, TIntermUnary *node)
  {
      if (node->isAssignment())
      {
          mIsValid = false;
      }
      return true;
  }
  
  ValidateGlobalInitializerTraverser::ValidateGlobalInitializerTraverser(int shaderVersion,
                                                                         bool isWebGL)
      : TIntermTraverser(true, false, false, nullptr),
        mShaderVersion(shaderVersion),
        mIsWebGL(isWebGL),
        mIsValid(true),
        mIssueWarning(false)
  {
      setMaxAllowedDepth(kMaxAllowedTraversalDepth);
  }
  
  }  // namespace
  
  bool ValidateGlobalInitializer(TIntermTyped *initializer,
                                 int shaderVersion,
                                 bool isWebGL,
                                 bool *warning)
  {
      ValidateGlobalInitializerTraverser validate(shaderVersion, isWebGL);
      initializer->traverse(&validate);
      ASSERT(warning != nullptr);
      *warning = validate.issueWarning();
      return validate.isValid();
  }
  
  }  // namespace sh
  

Download