kc3-lang/angle/src/compiler/translator/tree_ops/d3d/RewriteUnaryMinusOperatorInt.cpp

• Show log

  Commit

• Hash : a65b4056
  Author :
  Date : 2021-07-30T23:00:57
  

  Reland "Translator: Clean up type cloning"
  
  This is a reland of f016c4352f5203c10511df078b1ed5359afc1b35
  
  Original change's description:
  > Translator: Clean up type cloning
  >
  > TType has a constructor that aids cloning + helpers to convert between
  > types.  A number of places where a type is constructed from the
  > information gathered from another type is changed to clone the type and
  > then use one of these helpers.
  >
  > This clean up is part of an ongoing work to improve precision handling.
  > This change removes many references to TType::getPrecision().
  >
  > Bug: angleproject:4889
  > Change-Id: Ib85659ab5363b56ad298f8648fca856edc1ebf8b
  > Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3063944
  > Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  > Reviewed-by: Jamie Madill <jmadill@chromium.org>
  > Reviewed-by: Tim Van Patten <timvp@google.com>
  
  Bug: angleproject:4889
  Change-Id: I35772f178eb4f6cf2b64bfeb37a4a144acdb4daf
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3067802
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/compiler/translator/tree_ops/d3d/RewriteUnaryMinusOperatorInt.cpp

• //
  // Copyright 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.
  //
  // Implementation of evaluating unary integer variable bug workaround.
  // See header for more info.
  
  #include "compiler/translator/tree_ops/d3d/RewriteUnaryMinusOperatorInt.h"
  
  #include "compiler/translator/tree_util/IntermTraverse.h"
  
  namespace sh
  {
  
  namespace
  {
  
  class Traverser : public TIntermTraverser
  {
    public:
      ANGLE_NO_DISCARD static bool Apply(TCompiler *compiler, TIntermNode *root);
  
    private:
      Traverser();
      bool visitUnary(Visit visit, TIntermUnary *node) override;
      void nextIteration();
  
      bool mFound = false;
  };
  
  // static
  bool Traverser::Apply(TCompiler *compiler, TIntermNode *root)
  {
      Traverser traverser;
      do
      {
          traverser.nextIteration();
          root->traverse(&traverser);
          if (traverser.mFound)
          {
              if (!traverser.updateTree(compiler, root))
              {
                  return false;
              }
          }
      } while (traverser.mFound);
  
      return true;
  }
  
  Traverser::Traverser() : TIntermTraverser(true, false, false) {}
  
  void Traverser::nextIteration()
  {
      mFound = false;
  }
  
  bool Traverser::visitUnary(Visit visit, TIntermUnary *node)
  {
      if (mFound)
      {
          return false;
      }
  
      // Decide if the current unary operator is unary minus.
      if (node->getOp() != EOpNegative)
      {
          return true;
      }
  
      // Decide if the current operand is an integer variable.
      TIntermTyped *opr = node->getOperand();
      if (!opr->getType().isScalarInt())
      {
          return true;
      }
  
      // Potential problem case detected, apply workaround: -(int) -> ~(int) + 1.
      // ~(int)
      TIntermUnary *bitwiseNot = new TIntermUnary(EOpBitwiseNot, opr, nullptr);
      bitwiseNot->setLine(opr->getLine());
  
      // Constant 1 (or 1u)
      TConstantUnion *one = new TConstantUnion();
      if (opr->getType().getBasicType() == EbtInt)
      {
          one->setIConst(1);
      }
      else
      {
          one->setUConst(1u);
      }
      TType *oneType = new TType(opr->getType());
      oneType->setQualifier(EvqConst);
  
      TIntermConstantUnion *oneNode = new TIntermConstantUnion(one, *oneType);
      oneNode->setLine(opr->getLine());
  
      // ~(int) + 1
      TIntermBinary *add = new TIntermBinary(EOpAdd, bitwiseNot, oneNode);
      add->setLine(opr->getLine());
  
      queueReplacement(add, OriginalNode::IS_DROPPED);
  
      mFound = true;
      return false;
  }
  
  }  // anonymous namespace
  
  bool RewriteUnaryMinusOperatorInt(TCompiler *compiler, TIntermNode *root)
  {
      return Traverser::Apply(compiler, root);
  }
  
  }  // namespace sh
  

Download