Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 96 insertions, 96 deletions

diff --git a/contrib/libs/llvm12/include/llvm/Analysis/ScalarEvolutionExpressions.h b/contrib/libs/llvm12/include/llvm/Analysis/ScalarEvolutionExpressions.h
index 1841c92d43..d0d9f176df 100644
--- a/contrib/libs/llvm12/include/llvm/Analysis/ScalarEvolutionExpressions.h
+++ b/contrib/libs/llvm12/include/llvm/Analysis/ScalarEvolutionExpressions.h
@@ -42,12 +42,12 @@ class ConstantRange;
 class Loop;
 class Type;
 
-  enum SCEVTypes : unsigned short {
+  enum SCEVTypes : unsigned short { 
     // These should be ordered in terms of increasing complexity to make the
     // folders simpler.
     scConstant, scTruncate, scZeroExtend, scSignExtend, scAddExpr, scMulExpr,
     scUDivExpr, scAddRecExpr, scUMaxExpr, scSMaxExpr, scUMinExpr, scSMinExpr,
-    scPtrToInt, scUnknown, scCouldNotCompute
+    scPtrToInt, scUnknown, scCouldNotCompute 
   };
 
   /// This class represents a constant integer value.
@@ -81,58 +81,58 @@ class Type;
   /// This is the base class for unary cast operator classes.
   class SCEVCastExpr : public SCEV {
   protected:
-    std::array<const SCEV *, 1> Operands;
+    std::array<const SCEV *, 1> Operands; 
     Type *Ty;
 
-    SCEVCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy, const SCEV *op,
-                 Type *ty);
+    SCEVCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy, const SCEV *op, 
+                 Type *ty); 
 
   public:
-    const SCEV *getOperand() const { return Operands[0]; }
-    const SCEV *getOperand(unsigned i) const {
-      assert(i == 0 && "Operand index out of range!");
-      return Operands[0];
-    }
-    using op_iterator = std::array<const SCEV *, 1>::const_iterator;
-    using op_range = iterator_range<op_iterator>;
-
-    op_range operands() const {
-      return make_range(Operands.begin(), Operands.end());
-    }
-    size_t getNumOperands() const { return 1; }
+    const SCEV *getOperand() const { return Operands[0]; } 
+    const SCEV *getOperand(unsigned i) const { 
+      assert(i == 0 && "Operand index out of range!"); 
+      return Operands[0]; 
+    } 
+    using op_iterator = std::array<const SCEV *, 1>::const_iterator; 
+    using op_range = iterator_range<op_iterator>; 
+ 
+    op_range operands() const { 
+      return make_range(Operands.begin(), Operands.end()); 
+    } 
+    size_t getNumOperands() const { return 1; } 
     Type *getType() const { return Ty; }
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     static bool classof(const SCEV *S) {
-      return S->getSCEVType() == scPtrToInt || S->getSCEVType() == scTruncate ||
-             S->getSCEVType() == scZeroExtend ||
-             S->getSCEVType() == scSignExtend;
-    }
-  };
-
-  /// This class represents a cast from a pointer to a pointer-sized integer
-  /// value.
-  class SCEVPtrToIntExpr : public SCEVCastExpr {
-    friend class ScalarEvolution;
-
-    SCEVPtrToIntExpr(const FoldingSetNodeIDRef ID, const SCEV *Op, Type *ITy);
-
-  public:
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const SCEV *S) {
-      return S->getSCEVType() == scPtrToInt;
-    }
-  };
-
-  /// This is the base class for unary integral cast operator classes.
-  class SCEVIntegralCastExpr : public SCEVCastExpr {
-  protected:
-    SCEVIntegralCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy,
-                         const SCEV *op, Type *ty);
-
-  public:
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    static bool classof(const SCEV *S) {
+      return S->getSCEVType() == scPtrToInt || S->getSCEVType() == scTruncate || 
+             S->getSCEVType() == scZeroExtend || 
+             S->getSCEVType() == scSignExtend; 
+    } 
+  }; 
+ 
+  /// This class represents a cast from a pointer to a pointer-sized integer 
+  /// value. 
+  class SCEVPtrToIntExpr : public SCEVCastExpr { 
+    friend class ScalarEvolution; 
+ 
+    SCEVPtrToIntExpr(const FoldingSetNodeIDRef ID, const SCEV *Op, Type *ITy); 
+ 
+  public: 
+    /// Methods for support type inquiry through isa, cast, and dyn_cast: 
+    static bool classof(const SCEV *S) { 
+      return S->getSCEVType() == scPtrToInt; 
+    } 
+  }; 
+ 
+  /// This is the base class for unary integral cast operator classes. 
+  class SCEVIntegralCastExpr : public SCEVCastExpr { 
+  protected: 
+    SCEVIntegralCastExpr(const FoldingSetNodeIDRef ID, SCEVTypes SCEVTy, 
+                         const SCEV *op, Type *ty); 
+ 
+  public: 
+    /// Methods for support type inquiry through isa, cast, and dyn_cast: 
+    static bool classof(const SCEV *S) { 
       return S->getSCEVType() == scTruncate ||
              S->getSCEVType() == scZeroExtend ||
              S->getSCEVType() == scSignExtend;
@@ -141,7 +141,7 @@ class Type;
 
   /// This class represents a truncation of an integer value to a
   /// smaller integer value.
-  class SCEVTruncateExpr : public SCEVIntegralCastExpr {
+  class SCEVTruncateExpr : public SCEVIntegralCastExpr { 
     friend class ScalarEvolution;
 
     SCEVTruncateExpr(const FoldingSetNodeIDRef ID,
@@ -156,7 +156,7 @@ class Type;
 
   /// This class represents a zero extension of a small integer value
   /// to a larger integer value.
-  class SCEVZeroExtendExpr : public SCEVIntegralCastExpr {
+  class SCEVZeroExtendExpr : public SCEVIntegralCastExpr { 
     friend class ScalarEvolution;
 
     SCEVZeroExtendExpr(const FoldingSetNodeIDRef ID,
@@ -171,7 +171,7 @@ class Type;
 
   /// This class represents a sign extension of a small integer value
   /// to a larger integer value.
-  class SCEVSignExtendExpr : public SCEVIntegralCastExpr {
+  class SCEVSignExtendExpr : public SCEVIntegralCastExpr { 
     friend class ScalarEvolution;
 
     SCEVSignExtendExpr(const FoldingSetNodeIDRef ID,
@@ -310,29 +310,29 @@ class Type;
   class SCEVUDivExpr : public SCEV {
     friend class ScalarEvolution;
 
-    std::array<const SCEV *, 2> Operands;
+    std::array<const SCEV *, 2> Operands; 
 
     SCEVUDivExpr(const FoldingSetNodeIDRef ID, const SCEV *lhs, const SCEV *rhs)
-        : SCEV(ID, scUDivExpr, computeExpressionSize({lhs, rhs})) {
-        Operands[0] = lhs;
-        Operands[1] = rhs;
-      }
+        : SCEV(ID, scUDivExpr, computeExpressionSize({lhs, rhs})) { 
+        Operands[0] = lhs; 
+        Operands[1] = rhs; 
+      } 
 
   public:
-    const SCEV *getLHS() const { return Operands[0]; }
-    const SCEV *getRHS() const { return Operands[1]; }
-    size_t getNumOperands() const { return 2; }
-    const SCEV *getOperand(unsigned i) const {
-      assert((i == 0 || i == 1) && "Operand index out of range!");
-      return i == 0 ? getLHS() : getRHS();
-    }
-
-    using op_iterator = std::array<const SCEV *, 2>::const_iterator;
-    using op_range = iterator_range<op_iterator>;
-    op_range operands() const {
-      return make_range(Operands.begin(), Operands.end());
-    }
-
+    const SCEV *getLHS() const { return Operands[0]; } 
+    const SCEV *getRHS() const { return Operands[1]; } 
+    size_t getNumOperands() const { return 2; } 
+    const SCEV *getOperand(unsigned i) const { 
+      assert((i == 0 || i == 1) && "Operand index out of range!"); 
+      return i == 0 ? getLHS() : getRHS(); 
+    } 
+
+    using op_iterator = std::array<const SCEV *, 2>::const_iterator; 
+    using op_range = iterator_range<op_iterator>; 
+    op_range operands() const { 
+      return make_range(Operands.begin(), Operands.end()); 
+    } 
+ 
     Type *getType() const {
       // In most cases the types of LHS and RHS will be the same, but in some
       // crazy cases one or the other may be a pointer. ScalarEvolution doesn't
@@ -448,7 +448,7 @@ class Type;
 
   public:
     static bool classof(const SCEV *S) {
-      return isMinMaxType(S->getSCEVType());
+      return isMinMaxType(S->getSCEVType()); 
     }
 
     static enum SCEVTypes negate(enum SCEVTypes T) {
@@ -577,8 +577,8 @@ class Type;
       switch (S->getSCEVType()) {
       case scConstant:
         return ((SC*)this)->visitConstant((const SCEVConstant*)S);
-      case scPtrToInt:
-        return ((SC *)this)->visitPtrToIntExpr((const SCEVPtrToIntExpr *)S);
+      case scPtrToInt: 
+        return ((SC *)this)->visitPtrToIntExpr((const SCEVPtrToIntExpr *)S); 
       case scTruncate:
         return ((SC*)this)->visitTruncateExpr((const SCEVTruncateExpr*)S);
       case scZeroExtend:
@@ -606,7 +606,7 @@ class Type;
       case scCouldNotCompute:
         return ((SC*)this)->visitCouldNotCompute((const SCEVCouldNotCompute*)S);
       }
-      llvm_unreachable("Unknown SCEV kind!");
+      llvm_unreachable("Unknown SCEV kind!"); 
     }
 
     RetVal visitCouldNotCompute(const SCEVCouldNotCompute *S) {
@@ -643,13 +643,13 @@ class Type;
         switch (S->getSCEVType()) {
         case scConstant:
         case scUnknown:
-          continue;
-        case scPtrToInt:
+          continue; 
+        case scPtrToInt: 
         case scTruncate:
         case scZeroExtend:
         case scSignExtend:
           push(cast<SCEVCastExpr>(S)->getOperand());
-          continue;
+          continue; 
         case scAddExpr:
         case scMulExpr:
         case scSMaxExpr:
@@ -659,17 +659,17 @@ class Type;
         case scAddRecExpr:
           for (const auto *Op : cast<SCEVNAryExpr>(S)->operands())
             push(Op);
-          continue;
+          continue; 
         case scUDivExpr: {
           const SCEVUDivExpr *UDiv = cast<SCEVUDivExpr>(S);
           push(UDiv->getLHS());
           push(UDiv->getRHS());
-          continue;
+          continue; 
         }
         case scCouldNotCompute:
           llvm_unreachable("Attempt to use a SCEVCouldNotCompute object!");
         }
-        llvm_unreachable("Unknown SCEV kind!");
+        llvm_unreachable("Unknown SCEV kind!"); 
       }
     }
   };
@@ -737,13 +737,13 @@ class Type;
       return Constant;
     }
 
-    const SCEV *visitPtrToIntExpr(const SCEVPtrToIntExpr *Expr) {
-      const SCEV *Operand = ((SC *)this)->visit(Expr->getOperand());
-      return Operand == Expr->getOperand()
-                 ? Expr
-                 : SE.getPtrToIntExpr(Operand, Expr->getType());
-    }
-
+    const SCEV *visitPtrToIntExpr(const SCEVPtrToIntExpr *Expr) { 
+      const SCEV *Operand = ((SC *)this)->visit(Expr->getOperand()); 
+      return Operand == Expr->getOperand() 
+                 ? Expr 
+                 : SE.getPtrToIntExpr(Operand, Expr->getType()); 
+    } 
+ 
     const SCEV *visitTruncateExpr(const SCEVTruncateExpr *Expr) {
       const SCEV *Operand = ((SC*)this)->visit(Expr->getOperand());
       return Operand == Expr->getOperand()
@@ -854,30 +854,30 @@ class Type;
   };
 
   using ValueToValueMap = DenseMap<const Value *, Value *>;
-  using ValueToSCEVMapTy = DenseMap<const Value *, const SCEV *>;
+  using ValueToSCEVMapTy = DenseMap<const Value *, const SCEV *>; 
 
   /// The SCEVParameterRewriter takes a scalar evolution expression and updates
-  /// the SCEVUnknown components following the Map (Value -> SCEV).
+  /// the SCEVUnknown components following the Map (Value -> SCEV). 
   class SCEVParameterRewriter : public SCEVRewriteVisitor<SCEVParameterRewriter> {
   public:
     static const SCEV *rewrite(const SCEV *Scev, ScalarEvolution &SE,
-                               ValueToSCEVMapTy &Map) {
-      SCEVParameterRewriter Rewriter(SE, Map);
+                               ValueToSCEVMapTy &Map) { 
+      SCEVParameterRewriter Rewriter(SE, Map); 
       return Rewriter.visit(Scev);
     }
 
-    SCEVParameterRewriter(ScalarEvolution &SE, ValueToSCEVMapTy &M)
-        : SCEVRewriteVisitor(SE), Map(M) {}
+    SCEVParameterRewriter(ScalarEvolution &SE, ValueToSCEVMapTy &M) 
+        : SCEVRewriteVisitor(SE), Map(M) {} 
 
     const SCEV *visitUnknown(const SCEVUnknown *Expr) {
-      auto I = Map.find(Expr->getValue());
-      if (I == Map.end())
-        return Expr;
-      return I->second;
+      auto I = Map.find(Expr->getValue()); 
+      if (I == Map.end()) 
+        return Expr; 
+      return I->second; 
     }
 
   private:
-    ValueToSCEVMapTy &Map;
+    ValueToSCEVMapTy &Map; 
   };
 
   using LoopToScevMapT = DenseMap<const Loop *, const SCEV *>;