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

• Show log

  Commit

• Hash : 1ecd14b8
  Author :
  Date : 2017-01-26T13:54:15
  

  Fold user-definedness of function nodes into TOperator
  
  Whether a function call is user-defined is not orthogonal to TOperator
  associated with the call node - other ops than function calls can't be
  user-defined. Because of this it makes sense to store the user-
  definedness by having different TOperator enums for different types of
  calls.
  
  This patch also tags internal helper functions that have a raw
  definition outside the AST with a separate TOperator enum. This way
  they can be handled with logic that is easy to understand. Before this,
  function calls like this left the user-defined bit unset, despite not
  really being built-ins either. The EmulatePrecision traverser uses
  this. This is also something that could be used to clean up built-in
  emulation in the future.
  
  BUG=angleproject:1490
  TEST=angle_unittests
  
  Change-Id: I597fcd9789d0cc22b689ef3ce5a0cc3f621d4859
  Reviewed-on: https://chromium-review.googlesource.com/433443
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.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/ParseContext.h"
  
  namespace sh
  {
  
  namespace
  {
  
  class ValidateGlobalInitializerTraverser : public TIntermTraverser
  {
    public:
      ValidateGlobalInitializerTraverser(const TParseContext *context);
  
      void visitSymbol(TIntermSymbol *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; }
      bool issueWarning() const { return mIssueWarning; }
  
    private:
      const TParseContext *mContext;
      bool mIsValid;
      bool mIssueWarning;
  };
  
  void ValidateGlobalInitializerTraverser::visitSymbol(TIntermSymbol *node)
  {
      const TSymbol *sym =
          mContext->symbolTable.find(node->getSymbol(), mContext->getShaderVersion());
      if (sym->isVariable())
      {
          // ESSL 1.00 section 4.3 (or ESSL 3.00 section 4.3):
          // Global initializers must be constant expressions.
          const TVariable *var = static_cast<const TVariable *>(sym);
          switch (var->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 (mContext->getShaderVersion() >= 300)
                  {
                      mIsValid = false;
                  }
                  else
                  {
                      mIssueWarning = true;
                  }
                  break;
              default:
                  mIsValid = false;
          }
      }
  }
  
  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(const TParseContext *context)
      : TIntermTraverser(true, false, false), mContext(context), mIsValid(true), mIssueWarning(false)
  {
  }
  
  }  // namespace
  
  bool ValidateGlobalInitializer(TIntermTyped *initializer,
                                 const TParseContext *context,
                                 bool *warning)
  {
      ValidateGlobalInitializerTraverser validate(context);
      initializer->traverse(&validate);
      ASSERT(warning != nullptr);
      *warning = validate.issueWarning();
      return validate.isValid();
  }
  
  }  // namespace sh
  

Download