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

1 files changed, 30 insertions, 30 deletions

diff --git a/contrib/libs/llvm12/include/llvm/Analysis/VectorUtils.h b/contrib/libs/llvm12/include/llvm/Analysis/VectorUtils.h
index dc23c9c9ee..82047c3aec 100644
--- a/contrib/libs/llvm12/include/llvm/Analysis/VectorUtils.h
+++ b/contrib/libs/llvm12/include/llvm/Analysis/VectorUtils.h
@@ -21,12 +21,12 @@
 #define LLVM_ANALYSIS_VECTORUTILS_H
 
 #include "llvm/ADT/MapVector.h"
-#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/SmallVector.h" 
 #include "llvm/Analysis/LoopAccessAnalysis.h"
 #include "llvm/Support/CheckedArithmetic.h"
 
 namespace llvm {
-class TargetLibraryInfo;
+class TargetLibraryInfo; 
 
 /// Describes the type of Parameters
 enum class VFParamKind {
@@ -106,8 +106,8 @@ struct VFShape {
   // Retrieve the VFShape that can be used to map a (scalar) function to itself,
   // with VF = 1.
   static VFShape getScalarShape(const CallInst &CI) {
-    return VFShape::get(CI, ElementCount::getFixed(1),
-                        /*HasGlobalPredicate*/ false);
+    return VFShape::get(CI, ElementCount::getFixed(1), 
+                        /*HasGlobalPredicate*/ false); 
   }
 
   // Retrieve the basic vectorization shape of the function, where all
@@ -122,7 +122,7 @@ struct VFShape {
       Parameters.push_back(
           VFParameter({CI.arg_size(), VFParamKind::GlobalPredicate}));
 
-    return {EC.getKnownMinValue(), EC.isScalable(), Parameters};
+    return {EC.getKnownMinValue(), EC.isScalable(), Parameters}; 
   }
   /// Sanity check on the Parameters in the VFShape.
   bool hasValidParameterList() const;
@@ -307,19 +307,19 @@ namespace Intrinsic {
 typedef unsigned ID;
 }
 
-/// A helper function for converting Scalar types to vector types. If
-/// the incoming type is void, we return void. If the EC represents a
-/// scalar, we return the scalar type.
-inline Type *ToVectorTy(Type *Scalar, ElementCount EC) {
-  if (Scalar->isVoidTy() || Scalar->isMetadataTy() || EC.isScalar())
+/// A helper function for converting Scalar types to vector types. If 
+/// the incoming type is void, we return void. If the EC represents a 
+/// scalar, we return the scalar type. 
+inline Type *ToVectorTy(Type *Scalar, ElementCount EC) { 
+  if (Scalar->isVoidTy() || Scalar->isMetadataTy() || EC.isScalar()) 
     return Scalar;
-  return VectorType::get(Scalar, EC);
-}
-
-inline Type *ToVectorTy(Type *Scalar, unsigned VF) {
-  return ToVectorTy(Scalar, ElementCount::getFixed(VF));
+  return VectorType::get(Scalar, EC); 
 }
 
+inline Type *ToVectorTy(Type *Scalar, unsigned VF) { 
+  return ToVectorTy(Scalar, ElementCount::getFixed(VF)); 
+} 
+ 
 /// Identify if the intrinsic is trivially vectorizable.
 /// This method returns true if the intrinsic's argument types are all scalars
 /// for the scalar form of the intrinsic and all vectors (or scalars handled by
@@ -365,7 +365,7 @@ int getSplatIndex(ArrayRef<int> Mask);
 /// Get splat value if the input is a splat vector or return nullptr.
 /// The value may be extracted from a splat constants vector or from
 /// a sequence of instructions that broadcast a single value into a vector.
-Value *getSplatValue(const Value *V);
+Value *getSplatValue(const Value *V); 
 
 /// Return true if each element of the vector value \p V is poisoned or equal to
 /// every other non-poisoned element. If an index element is specified, either
@@ -551,20 +551,20 @@ createSequentialMask(unsigned Start, unsigned NumInts, unsigned NumUndefs);
 /// elements, it will be padded with undefs.
 Value *concatenateVectors(IRBuilderBase &Builder, ArrayRef<Value *> Vecs);
 
-/// Given a mask vector of i1, Return true if all of the elements of this
-/// predicate mask are known to be false or undef.  That is, return true if all
-/// lanes can be assumed inactive.
+/// Given a mask vector of i1, Return true if all of the elements of this 
+/// predicate mask are known to be false or undef.  That is, return true if all 
+/// lanes can be assumed inactive. 
 bool maskIsAllZeroOrUndef(Value *Mask);
 
-/// Given a mask vector of i1, Return true if all of the elements of this
-/// predicate mask are known to be true or undef.  That is, return true if all
-/// lanes can be assumed active.
+/// Given a mask vector of i1, Return true if all of the elements of this 
+/// predicate mask are known to be true or undef.  That is, return true if all 
+/// lanes can be assumed active. 
 bool maskIsAllOneOrUndef(Value *Mask);
 
 /// Given a mask vector of the form <Y x i1>, return an APInt (of bitwidth Y)
 /// for each lane which may be active.
 APInt possiblyDemandedEltsInMask(Value *Mask);
-
+ 
 /// The group of interleaved loads/stores sharing the same stride and
 /// close to each other.
 ///
@@ -627,11 +627,11 @@ public:
       return false;
     int32_t Key = *MaybeKey;
 
-    // Skip if the key is used for either the tombstone or empty special values.
-    if (DenseMapInfo<int32_t>::getTombstoneKey() == Key ||
-        DenseMapInfo<int32_t>::getEmptyKey() == Key)
-      return false;
-
+    // Skip if the key is used for either the tombstone or empty special values. 
+    if (DenseMapInfo<int32_t>::getTombstoneKey() == Key || 
+        DenseMapInfo<int32_t>::getEmptyKey() == Key) 
+      return false; 
+ 
     // Skip if there is already a member with the same index.
     if (Members.find(Key) != Members.end())
       return false;
@@ -667,7 +667,7 @@ public:
   /// \returns nullptr if contains no such member.
   InstTy *getMember(uint32_t Index) const {
     int32_t Key = SmallestKey + Index;
-    return Members.lookup(Key);
+    return Members.lookup(Key); 
   }
 
   /// Get the index for the given member. Unlike the key in the member
@@ -785,7 +785,7 @@ public:
   /// \returns nullptr if doesn't have such group.
   InterleaveGroup<Instruction> *
   getInterleaveGroup(const Instruction *Instr) const {
-    return InterleaveGroupMap.lookup(Instr);
+    return InterleaveGroupMap.lookup(Instr); 
   }
 
   iterator_range<SmallPtrSetIterator<llvm::InterleaveGroup<Instruction> *>>