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

1 files changed, 202 insertions, 202 deletions

diff --git a/contrib/libs/llvm12/lib/IR/Instructions.cpp b/contrib/libs/llvm12/lib/IR/Instructions.cpp
index 36db1098a1..429fe390f2 100644
--- a/contrib/libs/llvm12/lib/IR/Instructions.cpp
+++ b/contrib/libs/llvm12/lib/IR/Instructions.cpp
@@ -49,14 +49,14 @@ using namespace llvm;
 //                            AllocaInst Class
 //===----------------------------------------------------------------------===//
 
-Optional<TypeSize>
+Optional<TypeSize> 
 AllocaInst::getAllocationSizeInBits(const DataLayout &DL) const {
-  TypeSize Size = DL.getTypeAllocSizeInBits(getAllocatedType());
+  TypeSize Size = DL.getTypeAllocSizeInBits(getAllocatedType()); 
   if (isArrayAllocation()) {
     auto *C = dyn_cast<ConstantInt>(getArraySize());
     if (!C)
       return None;
-    assert(!Size.isScalable() && "Array elements cannot have a scalable size");
+    assert(!Size.isScalable() && "Array elements cannot have a scalable size"); 
     Size *= C->getZExtValue();
   }
   return Size;
@@ -400,7 +400,7 @@ CallBase::BundleOpInfo &CallBase::getBundleOpInfoForOperand(unsigned OpIdx) {
 
   bundle_op_iterator Begin = bundle_op_info_begin();
   bundle_op_iterator End = bundle_op_info_end();
-  bundle_op_iterator Current = Begin;
+  bundle_op_iterator Current = Begin; 
 
   while (Begin != End) {
     unsigned ScaledOperandPerBundle =
@@ -506,18 +506,18 @@ CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB,
   return NewCI;
 }
 
-CallInst *CallInst::CreateWithReplacedBundle(CallInst *CI, OperandBundleDef OpB,
-                                             Instruction *InsertPt) {
-  SmallVector<OperandBundleDef, 2> OpDefs;
-  for (unsigned i = 0, e = CI->getNumOperandBundles(); i < e; ++i) {
-    auto ChildOB = CI->getOperandBundleAt(i);
-    if (ChildOB.getTagName() != OpB.getTag())
-      OpDefs.emplace_back(ChildOB);
-  }
-  OpDefs.emplace_back(OpB);
-  return CallInst::Create(CI, OpDefs, InsertPt);
-}
-
+CallInst *CallInst::CreateWithReplacedBundle(CallInst *CI, OperandBundleDef OpB, 
+                                             Instruction *InsertPt) { 
+  SmallVector<OperandBundleDef, 2> OpDefs; 
+  for (unsigned i = 0, e = CI->getNumOperandBundles(); i < e; ++i) { 
+    auto ChildOB = CI->getOperandBundleAt(i); 
+    if (ChildOB.getTagName() != OpB.getTag()) 
+      OpDefs.emplace_back(ChildOB); 
+  } 
+  OpDefs.emplace_back(OpB); 
+  return CallInst::Create(CI, OpDefs, InsertPt); 
+} 
+ 
 // Update profile weight for call instruction by scaling it using the ratio
 // of S/T. The meaning of "branch_weights" meta data for call instruction is
 // transfered to represent call count.
@@ -551,9 +551,9 @@ void CallInst::updateProfWeight(uint64_t S, uint64_t T) {
                        ->getValue()
                        .getZExtValue());
     Val *= APS;
-    Vals.push_back(MDB.createConstant(
-        ConstantInt::get(Type::getInt32Ty(getContext()),
-                         Val.udiv(APT).getLimitedValue(UINT32_MAX))));
+    Vals.push_back(MDB.createConstant( 
+        ConstantInt::get(Type::getInt32Ty(getContext()), 
+                         Val.udiv(APT).getLimitedValue(UINT32_MAX)))); 
   } else if (ProfDataName->getString().equals("VP"))
     for (unsigned i = 1; i < ProfileData->getNumOperands(); i += 2) {
       // The first value is the key of the value profile, which will not change.
@@ -830,18 +830,18 @@ InvokeInst *InvokeInst::Create(InvokeInst *II, ArrayRef<OperandBundleDef> OpB,
   return NewII;
 }
 
-InvokeInst *InvokeInst::CreateWithReplacedBundle(InvokeInst *II,
-                                                 OperandBundleDef OpB,
-                                                 Instruction *InsertPt) {
-  SmallVector<OperandBundleDef, 2> OpDefs;
-  for (unsigned i = 0, e = II->getNumOperandBundles(); i < e; ++i) {
-    auto ChildOB = II->getOperandBundleAt(i);
-    if (ChildOB.getTagName() != OpB.getTag())
-      OpDefs.emplace_back(ChildOB);
-  }
-  OpDefs.emplace_back(OpB);
-  return InvokeInst::Create(II, OpDefs, InsertPt);
-}
+InvokeInst *InvokeInst::CreateWithReplacedBundle(InvokeInst *II, 
+                                                 OperandBundleDef OpB, 
+                                                 Instruction *InsertPt) { 
+  SmallVector<OperandBundleDef, 2> OpDefs; 
+  for (unsigned i = 0, e = II->getNumOperandBundles(); i < e; ++i) { 
+    auto ChildOB = II->getOperandBundleAt(i); 
+    if (ChildOB.getTagName() != OpB.getTag()) 
+      OpDefs.emplace_back(ChildOB); 
+  } 
+  OpDefs.emplace_back(OpB); 
+  return InvokeInst::Create(II, OpDefs, InsertPt); 
+} 
 
 LandingPadInst *InvokeInst::getLandingPadInst() const {
   return cast<LandingPadInst>(getUnwindDest()->getFirstNonPHI());
@@ -1935,7 +1935,7 @@ ShuffleVectorInst::ShuffleVectorInst(Value *V1, Value *V2, ArrayRef<int> Mask,
 }
 
 void ShuffleVectorInst::commute() {
-  int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
+  int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); 
   int NumMaskElts = ShuffleMask.size();
   SmallVector<int, 16> NewMask(NumMaskElts);
   for (int i = 0; i != NumMaskElts; ++i) {
@@ -1959,8 +1959,8 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2,
     return false;
 
   // Make sure the mask elements make sense.
-  int V1Size =
-      cast<VectorType>(V1->getType())->getElementCount().getKnownMinValue();
+  int V1Size = 
+      cast<VectorType>(V1->getType())->getElementCount().getKnownMinValue(); 
   for (int Elem : Mask)
     if (Elem != UndefMaskElem && Elem >= V1Size * 2)
       return false;
@@ -1990,7 +1990,7 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2,
     return true;
 
   if (const auto *MV = dyn_cast<ConstantVector>(Mask)) {
-    unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements();
+    unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements(); 
     for (Value *Op : MV->operands()) {
       if (auto *CI = dyn_cast<ConstantInt>(Op)) {
         if (CI->uge(V1Size*2))
@@ -2003,9 +2003,9 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2,
   }
 
   if (const auto *CDS = dyn_cast<ConstantDataSequential>(Mask)) {
-    unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements();
-    for (unsigned i = 0, e = cast<FixedVectorType>(MaskTy)->getNumElements();
-         i != e; ++i)
+    unsigned V1Size = cast<FixedVectorType>(V1->getType())->getNumElements(); 
+    for (unsigned i = 0, e = cast<FixedVectorType>(MaskTy)->getNumElements(); 
+         i != e; ++i) 
       if (CDS->getElementAsInteger(i) >= V1Size*2)
         return false;
     return true;
@@ -2016,26 +2016,26 @@ bool ShuffleVectorInst::isValidOperands(const Value *V1, const Value *V2,
 
 void ShuffleVectorInst::getShuffleMask(const Constant *Mask,
                                        SmallVectorImpl<int> &Result) {
-  ElementCount EC = cast<VectorType>(Mask->getType())->getElementCount();
-
+  ElementCount EC = cast<VectorType>(Mask->getType())->getElementCount(); 
+ 
   if (isa<ConstantAggregateZero>(Mask)) {
-    Result.resize(EC.getKnownMinValue(), 0);
-    return;
-  }
-
-  Result.reserve(EC.getKnownMinValue());
-
-  if (EC.isScalable()) {
-    assert((isa<ConstantAggregateZero>(Mask) || isa<UndefValue>(Mask)) &&
-           "Scalable vector shuffle mask must be undef or zeroinitializer");
-    int MaskVal = isa<UndefValue>(Mask) ? -1 : 0;
-    for (unsigned I = 0; I < EC.getKnownMinValue(); ++I)
-      Result.emplace_back(MaskVal);
+    Result.resize(EC.getKnownMinValue(), 0); 
     return;
   }
-
-  unsigned NumElts = EC.getKnownMinValue();
-
+ 
+  Result.reserve(EC.getKnownMinValue()); 
+ 
+  if (EC.isScalable()) { 
+    assert((isa<ConstantAggregateZero>(Mask) || isa<UndefValue>(Mask)) && 
+           "Scalable vector shuffle mask must be undef or zeroinitializer"); 
+    int MaskVal = isa<UndefValue>(Mask) ? -1 : 0; 
+    for (unsigned I = 0; I < EC.getKnownMinValue(); ++I) 
+      Result.emplace_back(MaskVal); 
+    return; 
+  } 
+ 
+  unsigned NumElts = EC.getKnownMinValue(); 
+ 
   if (auto *CDS = dyn_cast<ConstantDataSequential>(Mask)) {
     for (unsigned i = 0; i != NumElts; ++i)
       Result.push_back(CDS->getElementAsInteger(i));
@@ -2217,14 +2217,14 @@ bool ShuffleVectorInst::isExtractSubvectorMask(ArrayRef<int> Mask,
 bool ShuffleVectorInst::isIdentityWithPadding() const {
   if (isa<UndefValue>(Op<2>()))
     return false;
-
-  // FIXME: Not currently possible to express a shuffle mask for a scalable
-  // vector for this case.
-  if (isa<ScalableVectorType>(getType()))
-    return false;
-
-  int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
-  int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements();
+ 
+  // FIXME: Not currently possible to express a shuffle mask for a scalable 
+  // vector for this case. 
+  if (isa<ScalableVectorType>(getType())) 
+    return false; 
+ 
+  int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); 
+  int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); 
   if (NumMaskElts <= NumOpElts)
     return false;
 
@@ -2246,7 +2246,7 @@ bool ShuffleVectorInst::isIdentityWithExtract() const {
     return false;
 
   // FIXME: Not currently possible to express a shuffle mask for a scalable
-  // vector for this case.
+  // vector for this case. 
   if (isa<ScalableVectorType>(getType()))
     return false;
 
@@ -2264,13 +2264,13 @@ bool ShuffleVectorInst::isConcat() const {
       isa<UndefValue>(Op<2>()))
     return false;
 
-  // FIXME: Not currently possible to express a shuffle mask for a scalable
-  // vector for this case.
-  if (isa<ScalableVectorType>(getType()))
-    return false;
-
-  int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements();
-  int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements();
+  // FIXME: Not currently possible to express a shuffle mask for a scalable 
+  // vector for this case. 
+  if (isa<ScalableVectorType>(getType())) 
+    return false; 
+ 
+  int NumOpElts = cast<FixedVectorType>(Op<0>()->getType())->getNumElements(); 
+  int NumMaskElts = cast<FixedVectorType>(getType())->getNumElements(); 
   if (NumMaskElts != NumOpElts * 2)
     return false;
 
@@ -2671,7 +2671,7 @@ bool CastInst::isNoopCast(Instruction::CastOps Opcode,
                           Type *SrcTy,
                           Type *DestTy,
                           const DataLayout &DL) {
-  assert(castIsValid(Opcode, SrcTy, DestTy) && "method precondition");
+  assert(castIsValid(Opcode, SrcTy, DestTy) && "method precondition"); 
   switch (Opcode) {
     default: llvm_unreachable("Invalid CastOp");
     case Instruction::Trunc:
@@ -3026,8 +3026,8 @@ CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty,
          "Invalid cast");
   assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast");
   assert((!Ty->isVectorTy() ||
-          cast<VectorType>(Ty)->getElementCount() ==
-              cast<VectorType>(S->getType())->getElementCount()) &&
+          cast<VectorType>(Ty)->getElementCount() == 
+              cast<VectorType>(S->getType())->getElementCount()) && 
          "Invalid cast");
 
   if (Ty->isIntOrIntVectorTy())
@@ -3045,8 +3045,8 @@ CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty,
          "Invalid cast");
   assert(Ty->isVectorTy() == S->getType()->isVectorTy() && "Invalid cast");
   assert((!Ty->isVectorTy() ||
-          cast<VectorType>(Ty)->getElementCount() ==
-              cast<VectorType>(S->getType())->getElementCount()) &&
+          cast<VectorType>(Ty)->getElementCount() == 
+              cast<VectorType>(S->getType())->getElementCount()) && 
          "Invalid cast");
 
   if (Ty->isIntOrIntVectorTy())
@@ -3221,7 +3221,7 @@ CastInst::getCastOpcode(
   // FIXME: Check address space sizes here
   if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy))
     if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy))
-      if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) {
+      if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) { 
         // An element by element cast.  Find the appropriate opcode based on the
         // element types.
         SrcTy = SrcVecTy->getElementType();
@@ -3311,7 +3311,7 @@ CastInst::getCastOpcode(
 /// it in one place and to eliminate the redundant code for getting the sizes
 /// of the types involved.
 bool
-CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) {
+CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) { 
   if (!SrcTy->isFirstClassType() || !DstTy->isFirstClassType() ||
       SrcTy->isAggregateType() || DstTy->isAggregateType())
     return false;
@@ -3327,9 +3327,9 @@ CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) {
   // scalar types means that checking that vector lengths match also checks that
   // scalars are not being converted to vectors or vectors to scalars).
   ElementCount SrcEC = SrcIsVec ? cast<VectorType>(SrcTy)->getElementCount()
-                                : ElementCount::getFixed(0);
+                                : ElementCount::getFixed(0); 
   ElementCount DstEC = DstIsVec ? cast<VectorType>(DstTy)->getElementCount()
-                                : ElementCount::getFixed(0);
+                                : ElementCount::getFixed(0); 
 
   // Switch on the opcode provided
   switch (op) {
@@ -3387,9 +3387,9 @@ CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) {
     if (SrcIsVec && DstIsVec)
       return SrcEC == DstEC;
     if (SrcIsVec)
-      return SrcEC == ElementCount::getFixed(1);
+      return SrcEC == ElementCount::getFixed(1); 
     if (DstIsVec)
-      return DstEC == ElementCount::getFixed(1);
+      return DstEC == ElementCount::getFixed(1); 
 
     return true;
   }
@@ -3640,12 +3640,12 @@ bool CmpInst::isCommutative() const {
   return cast<FCmpInst>(this)->isCommutative();
 }
 
-bool CmpInst::isEquality(Predicate P) {
-  if (ICmpInst::isIntPredicate(P))
-    return ICmpInst::isEquality(P);
-  if (FCmpInst::isFPPredicate(P))
-    return FCmpInst::isEquality(P);
-  llvm_unreachable("Unsupported predicate kind");
+bool CmpInst::isEquality(Predicate P) { 
+  if (ICmpInst::isIntPredicate(P)) 
+    return ICmpInst::isEquality(P); 
+  if (FCmpInst::isFPPredicate(P)) 
+    return FCmpInst::isEquality(P); 
+  llvm_unreachable("Unsupported predicate kind"); 
 }
 
 CmpInst::Predicate CmpInst::getInversePredicate(Predicate pred) {
@@ -3769,97 +3769,97 @@ CmpInst::Predicate CmpInst::getSwappedPredicate(Predicate pred) {
   }
 }
 
-bool CmpInst::isNonStrictPredicate(Predicate pred) {
-  switch (pred) {
-  case ICMP_SGE:
-  case ICMP_SLE:
-  case ICMP_UGE:
-  case ICMP_ULE:
-  case FCMP_OGE:
-  case FCMP_OLE:
-  case FCMP_UGE:
-  case FCMP_ULE:
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool CmpInst::isStrictPredicate(Predicate pred) {
-  switch (pred) {
-  case ICMP_SGT:
-  case ICMP_SLT:
-  case ICMP_UGT:
-  case ICMP_ULT:
-  case FCMP_OGT:
-  case FCMP_OLT:
-  case FCMP_UGT:
-  case FCMP_ULT:
-    return true;
-  default:
-    return false;
-  }
-}
-
-CmpInst::Predicate CmpInst::getStrictPredicate(Predicate pred) {
-  switch (pred) {
-  case ICMP_SGE:
-    return ICMP_SGT;
-  case ICMP_SLE:
-    return ICMP_SLT;
-  case ICMP_UGE:
-    return ICMP_UGT;
-  case ICMP_ULE:
-    return ICMP_ULT;
-  case FCMP_OGE:
-    return FCMP_OGT;
-  case FCMP_OLE:
-    return FCMP_OLT;
-  case FCMP_UGE:
-    return FCMP_UGT;
-  case FCMP_ULE:
-    return FCMP_ULT;
-  default:
-    return pred;
-  }
-}
-
+bool CmpInst::isNonStrictPredicate(Predicate pred) { 
+  switch (pred) { 
+  case ICMP_SGE: 
+  case ICMP_SLE: 
+  case ICMP_UGE: 
+  case ICMP_ULE: 
+  case FCMP_OGE: 
+  case FCMP_OLE: 
+  case FCMP_UGE: 
+  case FCMP_ULE: 
+    return true; 
+  default: 
+    return false; 
+  } 
+} 
+ 
+bool CmpInst::isStrictPredicate(Predicate pred) { 
+  switch (pred) { 
+  case ICMP_SGT: 
+  case ICMP_SLT: 
+  case ICMP_UGT: 
+  case ICMP_ULT: 
+  case FCMP_OGT: 
+  case FCMP_OLT: 
+  case FCMP_UGT: 
+  case FCMP_ULT: 
+    return true; 
+  default: 
+    return false; 
+  } 
+} 
+ 
+CmpInst::Predicate CmpInst::getStrictPredicate(Predicate pred) { 
+  switch (pred) { 
+  case ICMP_SGE: 
+    return ICMP_SGT; 
+  case ICMP_SLE: 
+    return ICMP_SLT; 
+  case ICMP_UGE: 
+    return ICMP_UGT; 
+  case ICMP_ULE: 
+    return ICMP_ULT; 
+  case FCMP_OGE: 
+    return FCMP_OGT; 
+  case FCMP_OLE: 
+    return FCMP_OLT; 
+  case FCMP_UGE: 
+    return FCMP_UGT; 
+  case FCMP_ULE: 
+    return FCMP_ULT; 
+  default: 
+    return pred; 
+  } 
+} 
+ 
 CmpInst::Predicate CmpInst::getNonStrictPredicate(Predicate pred) {
   switch (pred) {
-  case ICMP_SGT:
-    return ICMP_SGE;
-  case ICMP_SLT:
-    return ICMP_SLE;
-  case ICMP_UGT:
-    return ICMP_UGE;
-  case ICMP_ULT:
-    return ICMP_ULE;
-  case FCMP_OGT:
-    return FCMP_OGE;
-  case FCMP_OLT:
-    return FCMP_OLE;
-  case FCMP_UGT:
-    return FCMP_UGE;
-  case FCMP_ULT:
-    return FCMP_ULE;
-  default:
-    return pred;
+  case ICMP_SGT: 
+    return ICMP_SGE; 
+  case ICMP_SLT: 
+    return ICMP_SLE; 
+  case ICMP_UGT: 
+    return ICMP_UGE; 
+  case ICMP_ULT: 
+    return ICMP_ULE; 
+  case FCMP_OGT: 
+    return FCMP_OGE; 
+  case FCMP_OLT: 
+    return FCMP_OLE; 
+  case FCMP_UGT: 
+    return FCMP_UGE; 
+  case FCMP_ULT: 
+    return FCMP_ULE; 
+  default: 
+    return pred; 
   }
 }
 
-CmpInst::Predicate CmpInst::getFlippedStrictnessPredicate(Predicate pred) {
-  assert(CmpInst::isRelational(pred) && "Call only with relational predicate!");
-
-  if (isStrictPredicate(pred))
-    return getNonStrictPredicate(pred);
-  if (isNonStrictPredicate(pred))
-    return getStrictPredicate(pred);
-
-  llvm_unreachable("Unknown predicate!");
-}
-
+CmpInst::Predicate CmpInst::getFlippedStrictnessPredicate(Predicate pred) { 
+  assert(CmpInst::isRelational(pred) && "Call only with relational predicate!"); 
+ 
+  if (isStrictPredicate(pred)) 
+    return getNonStrictPredicate(pred); 
+  if (isNonStrictPredicate(pred)) 
+    return getStrictPredicate(pred); 
+ 
+  llvm_unreachable("Unknown predicate!"); 
+} 
+ 
 CmpInst::Predicate CmpInst::getSignedPredicate(Predicate pred) {
-  assert(CmpInst::isUnsigned(pred) && "Call only with unsigned predicates!");
+  assert(CmpInst::isUnsigned(pred) && "Call only with unsigned predicates!"); 
 
   switch (pred) {
   default:
@@ -3875,23 +3875,23 @@ CmpInst::Predicate CmpInst::getSignedPredicate(Predicate pred) {
   }
 }
 
-CmpInst::Predicate CmpInst::getUnsignedPredicate(Predicate pred) {
-  assert(CmpInst::isSigned(pred) && "Call only with signed predicates!");
-
-  switch (pred) {
-  default:
-    llvm_unreachable("Unknown predicate!");
-  case CmpInst::ICMP_SLT:
-    return CmpInst::ICMP_ULT;
-  case CmpInst::ICMP_SLE:
-    return CmpInst::ICMP_ULE;
-  case CmpInst::ICMP_SGT:
-    return CmpInst::ICMP_UGT;
-  case CmpInst::ICMP_SGE:
-    return CmpInst::ICMP_UGE;
-  }
-}
-
+CmpInst::Predicate CmpInst::getUnsignedPredicate(Predicate pred) { 
+  assert(CmpInst::isSigned(pred) && "Call only with signed predicates!"); 
+ 
+  switch (pred) { 
+  default: 
+    llvm_unreachable("Unknown predicate!"); 
+  case CmpInst::ICMP_SLT: 
+    return CmpInst::ICMP_ULT; 
+  case CmpInst::ICMP_SLE: 
+    return CmpInst::ICMP_ULE; 
+  case CmpInst::ICMP_SGT: 
+    return CmpInst::ICMP_UGT; 
+  case CmpInst::ICMP_SGE: 
+    return CmpInst::ICMP_UGE; 
+  } 
+} 
+ 
 bool CmpInst::isUnsigned(Predicate predicate) {
   switch (predicate) {
     default: return false;
@@ -3908,18 +3908,18 @@ bool CmpInst::isSigned(Predicate predicate) {
   }
 }
 
-CmpInst::Predicate CmpInst::getFlippedSignednessPredicate(Predicate pred) {
-  assert(CmpInst::isRelational(pred) &&
-         "Call only with non-equality predicates!");
-
-  if (isSigned(pred))
-    return getUnsignedPredicate(pred);
-  if (isUnsigned(pred))
-    return getSignedPredicate(pred);
-
-  llvm_unreachable("Unknown predicate!");
-}
-
+CmpInst::Predicate CmpInst::getFlippedSignednessPredicate(Predicate pred) { 
+  assert(CmpInst::isRelational(pred) && 
+         "Call only with non-equality predicates!"); 
+ 
+  if (isSigned(pred)) 
+    return getUnsignedPredicate(pred); 
+  if (isUnsigned(pred)) 
+    return getSignedPredicate(pred); 
+ 
+  llvm_unreachable("Unknown predicate!"); 
+} 
+ 
 bool CmpInst::isOrdered(Predicate predicate) {
   switch (predicate) {
     default: return false;