Use std::is_sorted instead of manual loops. NFC

[oota-llvm.git] / lib / Analysis / VectorUtils.cpp

diff --git a/lib/Analysis/VectorUtils.cpp b/lib/Analysis/VectorUtils.cpp
index 4153c843c40eba11f98bfc70ded54514e20b04a9..4b244ec5e1f6236a6e284690f1130cf5626b70b6 100644 (file)
--- a/lib/Analysis/VectorUtils.cpp
+++ b/lib/Analysis/VectorUtils.cpp
@@ -324,8 +324,7 @@ Value *llvm::getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
       if (M->getOperand(0)->getSCEVType() != scConstant)
         return nullptr;
 
-      const APInt &APStepVal =
-          cast<SCEVConstant>(M->getOperand(0))->getValue()->getValue();
+      const APInt &APStepVal = cast<SCEVConstant>(M->getOperand(0))->getAPInt();
 
       // Huge step value - give up.
       if (APStepVal.getBitWidth() > 64)
@@ -417,9 +416,11 @@ Value *llvm::findScalarElement(Value *V, unsigned EltNo) {
 /// the input value is (1) a splat constants vector or (2) a sequence
 /// of instructions that broadcast a single value into a vector.
 ///
-llvm::Value *llvm::getSplatValue(Value *V) {
-  if (auto *CV = dyn_cast<ConstantDataVector>(V))
-    return CV->getSplatValue();
+const llvm::Value *llvm::getSplatValue(const Value *V) {
+
+  if (auto *C = dyn_cast<Constant>(V))
+    if (isa<VectorType>(V->getType()))
+      return C->getSplatValue();
 
   auto *ShuffleInst = dyn_cast<ShuffleVectorInst>(V);
   if (!ShuffleInst)
@@ -438,21 +439,21 @@ llvm::Value *llvm::getSplatValue(Value *V) {
   return InsertEltInst->getOperand(1);
 }
 
-DenseMap<Instruction*, uint64_t> llvm::computeMinimumValueSizes(
-  ArrayRef<BasicBlock*> Blocks, DemandedBits &DB,
-  const TargetTransformInfo *TTI) {
+MapVector<Instruction *, uint64_t>
+llvm::computeMinimumValueSizes(ArrayRef<BasicBlock *> Blocks, DemandedBits &DB,
+                               const TargetTransformInfo *TTI) {
 
   // DemandedBits will give us every value's live-out bits. But we want
   // to ensure no extra casts would need to be inserted, so every DAG
   // of connected values must have the same minimum bitwidth.
-  EquivalenceClasses<Value*> ECs;
-  SmallVector<Value*,16> Worklist;
-  SmallPtrSet<Value*,4> Roots;
-  SmallPtrSet<Value*,16> Visited;
-  DenseMap<Value*,uint64_t> DBits;
-  SmallPtrSet<Instruction*,4> InstructionSet;
-  DenseMap<Instruction*, uint64_t> MinBWs;
-  
+  EquivalenceClasses<Value *> ECs;
+  SmallVector<Value *, 16> Worklist;
+  SmallPtrSet<Value *, 4> Roots;
+  SmallPtrSet<Value *, 16> Visited;
+  DenseMap<Value *, uint64_t> DBits;
+  SmallPtrSet<Instruction *, 4> InstructionSet;
+  MapVector<Instruction *, uint64_t> MinBWs;
+
   // Determine the roots. We work bottom-up, from truncs or icmps.
   bool SeenExtFromIllegalType = false;
   for (auto *BB : Blocks)
@@ -462,7 +463,7 @@ DenseMap<Instruction*, uint64_t> llvm::computeMinimumValueSizes(
       if (TTI && (isa<ZExtInst>(&I) || isa<SExtInst>(&I)) &&
           !TTI->isTypeLegal(I.getOperand(0)->getType()))
         SeenExtFromIllegalType = true;
-    
+
       // Only deal with non-vector integers up to 64-bits wide.
       if ((isa<TruncInst>(&I) || isa<ICmpInst>(&I)) &&
           !I.getType()->isVectorTy() &&
@@ -471,7 +472,7 @@ DenseMap<Instruction*, uint64_t> llvm::computeMinimumValueSizes(
         // don't add it to the worklist.
         if (TTI && isa<TruncInst>(&I) && TTI->isTypeLegal(I.getType()))
           continue;
-      
+
         Worklist.push_back(&I);
         Roots.insert(&I);
       }
@@ -479,12 +480,12 @@ DenseMap<Instruction*, uint64_t> llvm::computeMinimumValueSizes(
   // Early exit.
   if (Worklist.empty() || (TTI && !SeenExtFromIllegalType))
     return MinBWs;
-  
+
   // Now proceed breadth-first, unioning values together.
   while (!Worklist.empty()) {
     Value *Val = Worklist.pop_back_val();
     Value *Leader = ECs.getOrInsertLeaderValue(Val);
-    
+
     if (Visited.count(Val))
       continue;
     Visited.insert(Val);
@@ -497,11 +498,11 @@ DenseMap<Instruction*, uint64_t> llvm::computeMinimumValueSizes(
     // If we encounter a type that is larger than 64 bits, we can't represent
     // it so bail out.
     if (DB.getDemandedBits(I).getBitWidth() > 64)
-      return DenseMap<Instruction*,uint64_t>();
-    
+      return MapVector<Instruction *, uint64_t>();
+
     uint64_t V = DB.getDemandedBits(I).getZExtValue();
     DBits[Leader] |= V;
-    
+
     // Casts, loads and instructions outside of our range terminate a chain
     // successfully.
     if (isa<SExtInst>(I) || isa<ZExtInst>(I) || isa<LoadInst>(I) ||
@@ -540,7 +541,7 @@ DenseMap<Instruction*, uint64_t> llvm::computeMinimumValueSizes(
     for (auto *U : I.first->users())
       if (U->getType()->isIntegerTy() && DBits.count(U) == 0)
         DBits[ECs.getOrInsertLeaderValue(I.first)] |= ~0ULL;
-  
+
   for (auto I = ECs.begin(), E = ECs.end(); I != E; ++I) {
     uint64_t LeaderDemandedBits = 0;
     for (auto MI = ECs.member_begin(I), ME = ECs.member_end(); MI != ME; ++MI)