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

• Show log

  Commit

• Hash : 9d737966
  Author :
  Date : 2019-08-14T12:25:12
  

  Standardize copyright notices to project style
  
  For all "ANGLE Project" copyrights, standardize to the format specified
  by the style guide. Changes:
  - "Copyright (c)" and "Copyright(c)" changed to just "Copyright".
  - Removed the second half of date ranges ("Y1Y1-Y2Y2"->"Y1Y1").
  - Fixed a small number of files that had no copyright date using the
    initial commit year from the version control history.
  - Fixed one instance of copyright being "The ANGLE Project" rather than
    "The ANGLE Project Authors"
  
  These changes are applied both to the copyright of source file, and
  where applicable to copyright statements that are generated by
  templates.
  
  BUG=angleproject:3811
  
  Change-Id: I973dd65e4ef9deeba232d5be74c768256a0eb2e5
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1754397
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/compiler/translator/ValidateSwitch.cpp

• //
  // Copyright 2002 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/ValidateSwitch.h"
  
  #include "compiler/translator/Diagnostics.h"
  #include "compiler/translator/tree_util/IntermTraverse.h"
  
  namespace sh
  {
  
  namespace
  {
  
  const int kMaxAllowedTraversalDepth = 256;
  
  class ValidateSwitch : public TIntermTraverser
  {
    public:
      static bool validate(TBasicType switchType,
                           TDiagnostics *diagnostics,
                           TIntermBlock *statementList,
                           const TSourceLoc &loc);
  
      void visitSymbol(TIntermSymbol *) override;
      void visitConstantUnion(TIntermConstantUnion *) override;
      bool visitDeclaration(Visit, TIntermDeclaration *) override;
      bool visitBlock(Visit visit, TIntermBlock *) override;
      bool visitBinary(Visit, TIntermBinary *) override;
      bool visitUnary(Visit, TIntermUnary *) override;
      bool visitTernary(Visit, TIntermTernary *) override;
      bool visitSwizzle(Visit, TIntermSwizzle *) override;
      bool visitIfElse(Visit visit, TIntermIfElse *) override;
      bool visitSwitch(Visit, TIntermSwitch *) override;
      bool visitCase(Visit, TIntermCase *node) override;
      bool visitAggregate(Visit, TIntermAggregate *) override;
      bool visitLoop(Visit visit, TIntermLoop *) override;
      bool visitBranch(Visit, TIntermBranch *) override;
  
    private:
      ValidateSwitch(TBasicType switchType, TDiagnostics *context);
  
      bool validateInternal(const TSourceLoc &loc);
  
      TBasicType mSwitchType;
      TDiagnostics *mDiagnostics;
      bool mCaseTypeMismatch;
      bool mFirstCaseFound;
      bool mStatementBeforeCase;
      bool mLastStatementWasCase;
      int mControlFlowDepth;
      bool mCaseInsideControlFlow;
      int mDefaultCount;
      std::set<int> mCasesSigned;
      std::set<unsigned int> mCasesUnsigned;
      bool mDuplicateCases;
  };
  
  bool ValidateSwitch::validate(TBasicType switchType,
                                TDiagnostics *diagnostics,
                                TIntermBlock *statementList,
                                const TSourceLoc &loc)
  {
      ValidateSwitch validate(switchType, diagnostics);
      ASSERT(statementList);
      statementList->traverse(&validate);
      return validate.validateInternal(loc);
  }
  
  ValidateSwitch::ValidateSwitch(TBasicType switchType, TDiagnostics *diagnostics)
      : TIntermTraverser(true, false, true, nullptr),
        mSwitchType(switchType),
        mDiagnostics(diagnostics),
        mCaseTypeMismatch(false),
        mFirstCaseFound(false),
        mStatementBeforeCase(false),
        mLastStatementWasCase(false),
        mControlFlowDepth(0),
        mCaseInsideControlFlow(false),
        mDefaultCount(0),
        mDuplicateCases(false)
  {
      setMaxAllowedDepth(kMaxAllowedTraversalDepth);
  }
  
  void ValidateSwitch::visitSymbol(TIntermSymbol *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
  }
  
  void ValidateSwitch::visitConstantUnion(TIntermConstantUnion *)
  {
      // Conditions of case labels are not traversed, so this is some other constant
      // Could be just a statement like "0;"
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
  }
  
  bool ValidateSwitch::visitDeclaration(Visit, TIntermDeclaration *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitBlock(Visit visit, TIntermBlock *)
  {
      if (getParentNode() != nullptr)
      {
          if (!mFirstCaseFound)
              mStatementBeforeCase = true;
          mLastStatementWasCase = false;
          if (visit == PreVisit)
              ++mControlFlowDepth;
          if (visit == PostVisit)
              --mControlFlowDepth;
      }
      return true;
  }
  
  bool ValidateSwitch::visitBinary(Visit, TIntermBinary *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitUnary(Visit, TIntermUnary *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitTernary(Visit, TIntermTernary *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitSwizzle(Visit, TIntermSwizzle *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitIfElse(Visit visit, TIntermIfElse *)
  {
      if (visit == PreVisit)
          ++mControlFlowDepth;
      if (visit == PostVisit)
          --mControlFlowDepth;
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitSwitch(Visit, TIntermSwitch *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      // Don't go into nested switch statements
      return false;
  }
  
  bool ValidateSwitch::visitCase(Visit, TIntermCase *node)
  {
      const char *nodeStr = node->hasCondition() ? "case" : "default";
      if (mControlFlowDepth > 0)
      {
          mDiagnostics->error(node->getLine(), "label statement nested inside control flow", nodeStr);
          mCaseInsideControlFlow = true;
      }
      mFirstCaseFound       = true;
      mLastStatementWasCase = true;
      if (!node->hasCondition())
      {
          ++mDefaultCount;
          if (mDefaultCount > 1)
          {
              mDiagnostics->error(node->getLine(), "duplicate default label", nodeStr);
          }
      }
      else
      {
          TIntermConstantUnion *condition = node->getCondition()->getAsConstantUnion();
          if (condition == nullptr)
          {
              // This can happen in error cases.
              return false;
          }
          TBasicType conditionType = condition->getBasicType();
          if (conditionType != mSwitchType)
          {
              mDiagnostics->error(condition->getLine(),
                                  "case label type does not match switch init-expression type",
                                  nodeStr);
              mCaseTypeMismatch = true;
          }
  
          if (conditionType == EbtInt)
          {
              int iConst = condition->getIConst(0);
              if (mCasesSigned.find(iConst) != mCasesSigned.end())
              {
                  mDiagnostics->error(condition->getLine(), "duplicate case label", nodeStr);
                  mDuplicateCases = true;
              }
              else
              {
                  mCasesSigned.insert(iConst);
              }
          }
          else if (conditionType == EbtUInt)
          {
              unsigned int uConst = condition->getUConst(0);
              if (mCasesUnsigned.find(uConst) != mCasesUnsigned.end())
              {
                  mDiagnostics->error(condition->getLine(), "duplicate case label", nodeStr);
                  mDuplicateCases = true;
              }
              else
              {
                  mCasesUnsigned.insert(uConst);
              }
          }
          // Other types are possible only in error cases, where the error has already been generated
          // when parsing the case statement.
      }
      // Don't traverse the condition of the case statement
      return false;
  }
  
  bool ValidateSwitch::visitAggregate(Visit visit, TIntermAggregate *)
  {
      if (getParentNode() != nullptr)
      {
          // This is not the statementList node, but some other node.
          if (!mFirstCaseFound)
              mStatementBeforeCase = true;
          mLastStatementWasCase = false;
      }
      return true;
  }
  
  bool ValidateSwitch::visitLoop(Visit visit, TIntermLoop *)
  {
      if (visit == PreVisit)
          ++mControlFlowDepth;
      if (visit == PostVisit)
          --mControlFlowDepth;
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitBranch(Visit, TIntermBranch *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::validateInternal(const TSourceLoc &loc)
  {
      if (mStatementBeforeCase)
      {
          mDiagnostics->error(loc, "statement before the first label", "switch");
      }
      if (mLastStatementWasCase)
      {
          // There have been some differences between versions of GLSL ES specs on whether this should
          // be an error or not, but as of early 2018 the latest discussion is that this is an error
          // also on GLSL ES versions newer than 3.00.
          mDiagnostics->error(
              loc, "no statement between the last label and the end of the switch statement",
              "switch");
      }
      if (getMaxDepth() >= kMaxAllowedTraversalDepth)
      {
          mDiagnostics->error(loc, "too complex expressions inside a switch statement", "switch");
      }
      return !mStatementBeforeCase && !mLastStatementWasCase && !mCaseInsideControlFlow &&
             !mCaseTypeMismatch && mDefaultCount <= 1 && !mDuplicateCases &&
             getMaxDepth() < kMaxAllowedTraversalDepth;
  }
  
  }  // anonymous namespace
  
  bool ValidateSwitchStatementList(TBasicType switchType,
                                   TDiagnostics *diagnostics,
                                   TIntermBlock *statementList,
                                   const TSourceLoc &loc)
  {
      return ValidateSwitch::validate(switchType, diagnostics, statementList, loc);
  }
  
  }  // namespace sh
  

Download