Cleanup: llvm::bsearch -> llvm::partition_point after r364719

MaskRay · MaskRay · commit 78ee2fbf984b · 2019-06-30T11:19:56.000Z
llvm-svn: 364720
diff --git a/clang-tools-extra/clangd/index/Symbol.cpp b/clang-tools-extra/clangd/index/Symbol.cpp
@@ -35,8 +35,8 @@ float quality(const Symbol &S) {
 }
 
 SymbolSlab::const_iterator SymbolSlab::find(const SymbolID &ID) const {
-  auto It =
-      llvm::bsearch(Symbols, [&](const Symbol &S) { return !(S.ID < ID); });
+  auto It = llvm::partition_point(Symbols,
+                                  [&](const Symbol &S) { return S.ID < ID; });
   if (It != Symbols.end() && It->ID == ID)
     return It;
   return Symbols.end();
diff --git a/clang/lib/Tooling/Syntax/Tokens.cpp b/clang/lib/Tooling/Syntax/Tokens.cpp
@@ -127,8 +127,8 @@ TokenBuffer::spelledForExpandedToken(const syntax::Token *Expanded) const {
 
   unsigned ExpandedIndex = Expanded - ExpandedTokens.data();
   // Find the first mapping that produced tokens after \p Expanded.
-  auto It = llvm::bsearch(File.Mappings, [&](const Mapping &M) {
-    return ExpandedIndex < M.BeginExpanded;
+  auto It = llvm::partition_point(File.Mappings, [&](const Mapping &M) {
+    return M.BeginExpanded <= ExpandedIndex;
   });
   // Our token could only be produced by the previous mapping.
   if (It == File.Mappings.begin()) {
@@ -212,8 +212,8 @@ TokenBuffer::expansionStartingAt(const syntax::Token *Spelled) const {
          Spelled < (File.SpelledTokens.data() + File.SpelledTokens.size()));
 
   unsigned SpelledIndex = Spelled - File.SpelledTokens.data();
-  auto M = llvm::bsearch(File.Mappings, [&](const Mapping &M) {
-    return SpelledIndex <= M.BeginSpelled;
+  auto M = llvm::partition_point(File.Mappings, [&](const Mapping &M) {
+    return M.BeginSpelled < SpelledIndex;
   });
   if (M == File.Mappings.end() || M->BeginSpelled != SpelledIndex)
     return llvm::None;
diff --git a/lld/ELF/DWARF.cpp b/lld/ELF/DWARF.cpp
@@ -82,7 +82,7 @@ Optional<RelocAddrEntry>
 LLDDwarfObj<ELFT>::findAux(const InputSectionBase &Sec, uint64_t Pos,
                            ArrayRef<RelTy> Rels) const {
   auto It =
-      llvm::bsearch(Rels, [=](const RelTy &A) { return Pos <= A.r_offset; });
+      partition_point(Rels, [=](const RelTy &A) { return A.r_offset < Pos; });
   if (It == Rels.end() || It->r_offset != Pos)
     return None;
   const RelTy &Rel = *It;
diff --git a/lld/ELF/InputSection.cpp b/lld/ELF/InputSection.cpp
@@ -1268,8 +1268,8 @@ SectionPiece *MergeInputSection::getSectionPiece(uint64_t Offset) {
 
   // If Offset is not at beginning of a section piece, it is not in the map.
   // In that case we need to  do a binary search of the original section piece vector.
-  auto It = llvm::bsearch(Pieces,
-                          [=](SectionPiece P) { return Offset < P.InputOff; });
+  auto It = partition_point(
+      Pieces, [=](SectionPiece P) { return P.InputOff <= Offset; });
   return &It[-1];
 }
 
diff --git a/llvm/include/llvm/ADT/STLExtras.h b/llvm/include/llvm/ADT/STLExtras.h
@@ -1322,13 +1322,12 @@ void stable_sort(R &&Range, Compare C) {
   std::stable_sort(adl_begin(Range), adl_end(Range), C);
 }
 
-/// Binary search for the first iterator in a range where a predicate is true.
-/// Requires that C is always false below some limit, and always true above it.
+/// Binary search for the first iterator in a range where a predicate is false.
+/// Requires that C is always true below some limit, and always false above it.
 template <typename R, typename Predicate,
           typename Val = decltype(*adl_begin(std::declval<R>()))>
-auto bsearch(R &&Range, Predicate P) -> decltype(adl_begin(Range)) {
-  return std::partition_point(adl_begin(Range), adl_end(Range),
-                              [&](const Val &V) { return !P(V); });
+auto partition_point(R &&Range, Predicate P) -> decltype(adl_begin(Range)) {
+  return std::partition_point(adl_begin(Range), adl_end(Range), P);
 }
 
 /// Wrapper function around std::equal to detect if all elements
diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h
@@ -473,9 +473,10 @@ class DWARFUnit {
   DWARFDie getDIEForOffset(uint32_t Offset) {
     extractDIEsIfNeeded(false);
     assert(!DieArray.empty());
-    auto It = llvm::bsearch(DieArray, [=](const DWARFDebugInfoEntry &LHS) {
-      return Offset <= LHS.getOffset();
-    });
+    auto It =
+        llvm::partition_point(DieArray, [=](const DWARFDebugInfoEntry &DIE) {
+          return DIE.getOffset() < Offset;
+        });
     if (It != DieArray.end() && It->getOffset() == Offset)
       return DWARFDie(this, &*It);
     return DWARFDie();
diff --git a/llvm/lib/Analysis/ProfileSummaryInfo.cpp b/llvm/lib/Analysis/ProfileSummaryInfo.cpp
@@ -60,8 +60,8 @@ static cl::opt<int> ProfileSummaryColdCount(
 // Find the summary entry for a desired percentile of counts.
 static const ProfileSummaryEntry &getEntryForPercentile(SummaryEntryVector &DS,
                                                         uint64_t Percentile) {
-  auto It = llvm::bsearch(DS, [=](const ProfileSummaryEntry &Entry) {
-    return Percentile <= Entry.Cutoff;
+  auto It = partition_point(DS, [=](const ProfileSummaryEntry &Entry) {
+    return Entry.Cutoff < Percentile;
   });
   // The required percentile has to be <= one of the percentiles in the
   // detailed summary.
diff --git a/llvm/lib/CodeGen/ExecutionDomainFix.cpp b/llvm/lib/CodeGen/ExecutionDomainFix.cpp
@@ -337,8 +337,8 @@ void ExecutionDomainFix::visitSoftInstr(MachineInstr *mi, unsigned mask) {
     // Sorted insertion.
     // Enables giving priority to the latest domains during merging.
     const int Def = RDA->getReachingDef(mi, RC->getRegister(rx));
-    auto I = llvm::bsearch(Regs, [&](int I) {
-      return Def < RDA->getReachingDef(mi, RC->getRegister(I));
+    auto I = partition_point(Regs, [&](int I) {
+      return RDA->getReachingDef(mi, RC->getRegister(I)) <= Def;
     });
     Regs.insert(I, rx);
   }
diff --git a/llvm/lib/CodeGen/GlobalISel/LegalizerInfo.cpp b/llvm/lib/CodeGen/GlobalISel/LegalizerInfo.cpp
@@ -544,11 +544,10 @@ LegalizerInfo::findAction(const SizeAndActionsVec &Vec, const uint32_t Size) {
   // Find the last element in Vec that has a bitsize equal to or smaller than
   // the requested bit size.
   // That is the element just before the first element that is bigger than Size.
-  auto VecIt = llvm::bsearch(
-      Vec, [=](const SizeAndAction &A) { return Size < A.first; });
-  assert(VecIt != Vec.begin() && "Does Vec not start with size 1?");
-  --VecIt;
-  int VecIdx = VecIt - Vec.begin();
+  auto It = partition_point(
+      Vec, [=](const SizeAndAction &A) { return A.first <= Size; });
+  assert(It != Vec.begin() && "Does Vec not start with size 1?");
+  int VecIdx = It - Vec.begin() - 1;
 
   LegalizeAction Action = Vec[VecIdx].second;
   switch (Action) {
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDebugAranges.cpp
@@ -115,7 +115,7 @@ void DWARFDebugAranges::construct() {
 
 uint32_t DWARFDebugAranges::findAddress(uint64_t Address) const {
   RangeCollIterator It =
-      llvm::bsearch(Aranges, [=](Range RHS) { return Address < RHS.HighPC(); });
+      partition_point(Aranges, [=](Range R) { return R.HighPC() <= Address; });
   if (It != Aranges.end() && It->LowPC <= Address)
     return It->CUOffset;
   return -1U;
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp
@@ -532,8 +532,8 @@ void DWARFDebugFrame::parse(DWARFDataExtractor Data) {
 }
 
 FrameEntry *DWARFDebugFrame::getEntryAtOffset(uint64_t Offset) const {
-  auto It = llvm::bsearch(Entries, [=](const std::unique_ptr<FrameEntry> &E) {
-    return Offset <= E->getOffset();
+  auto It = partition_point(Entries, [=](const std::unique_ptr<FrameEntry> &E) {
+    return E->getOffset() < Offset;
   });
   if (It != Entries.end() && (*It)->getOffset() == Offset)
     return It->get();
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
@@ -57,8 +57,8 @@ void DWARFDebugLoc::LocationList::dump(raw_ostream &OS, bool IsLittleEndian,
 
 DWARFDebugLoc::LocationList const *
 DWARFDebugLoc::getLocationListAtOffset(uint64_t Offset) const {
-  auto It = llvm::bsearch(
-      Locations, [=](const LocationList &L) { return Offset <= L.Offset; });
+  auto It = partition_point(
+      Locations, [=](const LocationList &L) { return L.Offset < Offset; });
   if (It != Locations.end() && It->Offset == Offset)
     return &(*It);
   return nullptr;
@@ -212,8 +212,8 @@ void DWARFDebugLoclists::parse(DataExtractor data, unsigned Version) {
 
 DWARFDebugLoclists::LocationList const *
 DWARFDebugLoclists::getLocationListAtOffset(uint64_t Offset) const {
-  auto It = llvm::bsearch(
-      Locations, [=](const LocationList &L) { return Offset <= L.Offset; });
+  auto It = partition_point(
+      Locations, [=](const LocationList &L) { return L.Offset < Offset; });
   if (It != Locations.end() && It->Offset == Offset)
     return &(*It);
   return nullptr;
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFUnitIndex.cpp b/llvm/lib/DebugInfo/DWARF/DWARFUnitIndex.cpp
@@ -172,8 +172,8 @@ DWARFUnitIndex::getFromOffset(uint32_t Offset) const {
              E2->Contributions[InfoColumn].Offset;
     });
   }
-  auto I = llvm::bsearch(OffsetLookup, [&](Entry *E2) {
-    return Offset < E2->Contributions[InfoColumn].Offset;
+  auto I = partition_point(OffsetLookup, [&](Entry *E2) {
+    return E2->Contributions[InfoColumn].Offset <= Offset;
   });
   if (I == OffsetLookup.begin())
     return nullptr;
diff --git a/llvm/lib/IR/DataLayout.cpp b/llvm/lib/IR/DataLayout.cpp
@@ -463,8 +463,8 @@ DataLayout::AlignmentsTy::iterator
 DataLayout::findAlignmentLowerBound(AlignTypeEnum AlignType,
                                     uint32_t BitWidth) {
   auto Pair = std::make_pair((unsigned)AlignType, BitWidth);
-  return llvm::bsearch(Alignments, [=](const LayoutAlignElem &E) {
-    return Pair <= std::make_pair(E.AlignType, E.TypeBitWidth);
+  return partition_point(Alignments, [=](const LayoutAlignElem &E) {
+    return std::make_pair(E.AlignType, E.TypeBitWidth) < Pair;
   });
 }
 
diff --git a/llvm/lib/IR/Function.cpp b/llvm/lib/IR/Function.cpp
@@ -533,9 +533,8 @@ static ArrayRef<const char *> findTargetSubtable(StringRef Name) {
   // Drop "llvm." and take the first dotted component. That will be the target
   // if this is target specific.
   StringRef Target = Name.drop_front(5).split('.').first;
-  auto It = llvm::bsearch(Targets, [=](const IntrinsicTargetInfo &TI) {
-    return Target <= TI.Name;
-  });
+  auto It = partition_point(
+      Targets, [=](const IntrinsicTargetInfo &TI) { return TI.Name < Target; });
   // We've either found the target or just fall back to the generic set, which
   // is always first.
   const auto &TI = It != Targets.end() && It->Name == Target ? *It : Targets[0];
diff --git a/llvm/lib/ProfileData/InstrProf.cpp b/llvm/lib/ProfileData/InstrProf.cpp
@@ -363,16 +363,15 @@ Error InstrProfSymtab::create(Module &M, bool InLTO) {
 
 uint64_t InstrProfSymtab::getFunctionHashFromAddress(uint64_t Address) {
   finalizeSymtab();
-  auto Result =
-      llvm::bsearch(AddrToMD5Map, [=](std::pair<uint64_t, uint64_t> A) {
-        return Address <= A.first;
-      });
+  auto It = partition_point(AddrToMD5Map, [=](std::pair<uint64_t, uint64_t> A) {
+    return A.first < Address;
+  });
   // Raw function pointer collected by value profiler may be from
   // external functions that are not instrumented. They won't have
   // mapping data to be used by the deserializer. Force the value to
   // be 0 in this case.
-  if (Result != AddrToMD5Map.end() && Result->first == Address)
-    return (uint64_t)Result->second;
+  if (It != AddrToMD5Map.end() && It->first == Address)
+    return (uint64_t)It->second;
   return 0;
 }
 
diff --git a/llvm/lib/Target/X86/X86InstrFMA3Info.cpp b/llvm/lib/Target/X86/X86InstrFMA3Info.cpp
@@ -158,8 +158,8 @@ const X86InstrFMA3Group *llvm::getFMA3Group(unsigned Opcode, uint64_t TSFlags) {
   // FMA 231 instructions have an opcode of 0xB6-0xBF
   unsigned FormIndex = ((BaseOpcode - 0x90) >> 4) & 0x3;
 
-  auto I = llvm::bsearch(Table, [=](const X86InstrFMA3Group &Group) {
-    return Opcode <= Group.Opcodes[FormIndex];
+  auto I = partition_point(Table, [=](const X86InstrFMA3Group &Group) {
+    return Group.Opcodes[FormIndex] < Opcode;
   });
   assert(I != Table.end() && I->Opcodes[FormIndex] == Opcode &&
          "Couldn't find FMA3 opcode!");
diff --git a/llvm/lib/TextAPI/MachO/InterfaceFile.cpp b/llvm/lib/TextAPI/MachO/InterfaceFile.cpp
@@ -14,17 +14,15 @@
 #include <iomanip>
 #include <sstream>
 
-using namespace llvm::MachO;
-
 namespace llvm {
 namespace MachO {
 namespace detail {
 template <typename C>
 typename C::iterator addEntry(C &Container, StringRef InstallName) {
-  auto I = llvm::bsearch(Container, [=](const InterfaceFileRef &O) {
-    return InstallName <= O.getInstallName();
+  auto I = partition_point(Container, [=](const InterfaceFileRef &O) {
+    return O.getInstallName() < InstallName;
   });
-  if ((I != std::end(Container)) && !(InstallName < I->getInstallName()))
+  if (I != Container.end() && I->getInstallName() == InstallName)
     return I;
 
   return Container.emplace(I, InstallName);
@@ -44,10 +42,10 @@ void InterfaceFile::addReexportedLibrary(StringRef InstallName,
 }
 
 void InterfaceFile::addUUID(Architecture Arch, StringRef UUID) {
-  auto I =
-      llvm::bsearch(UUIDs, [=](const std::pair<Architecture, std::string> &O) {
-        return Arch <= O.first;
-      });
+  auto I = partition_point(UUIDs,
+                           [=](const std::pair<Architecture, std::string> &O) {
+                             return O.first < Arch;
+                           });
 
   if (I != UUIDs.end() && Arch == I->first) {
     I->second = UUID;
diff --git a/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp b/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
@@ -278,8 +278,8 @@ void MemsetRanges::addRange(int64_t Start, int64_t Size, Value *Ptr,
                             unsigned Alignment, Instruction *Inst) {
   int64_t End = Start+Size;
 
-  range_iterator I = llvm::bsearch(
-      Ranges, [=](const MemsetRange &O) { return Start <= O.End; });
+  range_iterator I = partition_point(
+      Ranges, [=](const MemsetRange &O) { return O.End < Start; });
 
   // We now know that I == E, in which case we didn't find anything to merge
   // with, or that Start <= I->End.  If End < I->Start or I == E, then we need
diff --git a/llvm/tools/dsymutil/DwarfLinker.cpp b/llvm/tools/dsymutil/DwarfLinker.cpp
@@ -1767,8 +1767,8 @@ static void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
   }
 
   object::SectionedAddress Front = Seq.front().Address;
-  auto InsertPoint = llvm::bsearch(
-      Rows, [=](const DWARFDebugLine::Row &O) { return !(O.Address < Front); });
+  auto InsertPoint = partition_point(
+      Rows, [=](const DWARFDebugLine::Row &O) { return O.Address < Front; });
 
   // FIXME: this only removes the unneeded end_sequence if the
   // sequences have been inserted in order. Using a global sort like
diff --git a/llvm/tools/llvm-objdump/llvm-objdump.cpp b/llvm/tools/llvm-objdump/llvm-objdump.cpp
@@ -973,14 +973,15 @@ static bool shouldAdjustVA(const SectionRef &Section) {
 typedef std::pair<uint64_t, char> MappingSymbolPair;
 static char getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols,
                                  uint64_t Address) {
-  auto Sym = bsearch(MappingSymbols, [Address](const MappingSymbolPair &Val) {
-      return Val.first > Address;
-  });
+  auto It =
+      partition_point(MappingSymbols, [Address](const MappingSymbolPair &Val) {
+        return Val.first <= Address;
+      });
   // Return zero for any address before the first mapping symbol; this means
   // we should use the default disassembly mode, depending on the target.
-  if (Sym == MappingSymbols.begin())
+  if (It == MappingSymbols.begin())
     return '\x00';
-  return (Sym - 1)->second;
+  return (It - 1)->second;
 }
 
 static uint64_t
@@ -1119,9 +1120,9 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj,
       error(ExportEntry.getExportRVA(RVA));
 
       uint64_t VA = COFFObj->getImageBase() + RVA;
-      auto Sec = llvm::bsearch(
-          SectionAddresses, [VA](const std::pair<uint64_t, SectionRef> &RHS) {
-            return VA < RHS.first;
+      auto Sec = partition_point(
+          SectionAddresses, [VA](const std::pair<uint64_t, SectionRef> &O) {
+            return O.first <= VA;
           });
       if (Sec != SectionAddresses.begin()) {
         --Sec;
@@ -1378,10 +1379,10 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj,
             // N.B. We don't walk the relocations in the relocatable case yet.
             auto *TargetSectionSymbols = &Symbols;
             if (!Obj->isRelocatableObject()) {
-              auto It = llvm::bsearch(
+              auto It = partition_point(
                   SectionAddresses,
-                  [=](const std::pair<uint64_t, SectionRef> &RHS) {
-                    return Target < RHS.first;
+                  [=](const std::pair<uint64_t, SectionRef> &O) {
+                    return O.first <= Target;
                   });
               if (It != SectionAddresses.begin()) {
                 --It;
@@ -1394,17 +1395,17 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj,
             // Find the last symbol in the section whose offset is less than
             // or equal to the target. If there isn't a section that contains
             // the target, find the nearest preceding absolute symbol.
-            auto TargetSym = llvm::bsearch(
+            auto TargetSym = partition_point(
                 *TargetSectionSymbols,
-                [=](const std::tuple<uint64_t, StringRef, uint8_t> &RHS) {
-                  return Target < std::get<0>(RHS);
+                [=](const std::tuple<uint64_t, StringRef, uint8_t> &O) {
+                  return std::get<0>(O) <= Target;
                 });
             if (TargetSym == TargetSectionSymbols->begin()) {
               TargetSectionSymbols = &AbsoluteSymbols;
-              TargetSym = llvm::bsearch(
+              TargetSym = partition_point(
                   AbsoluteSymbols,
-                  [=](const std::tuple<uint64_t, StringRef, uint8_t> &RHS) {
-                    return Target < std::get<0>(RHS);
+                  [=](const std::tuple<uint64_t, StringRef, uint8_t> &O) {
+                    return std::get<0>(O) <= Target;
                   });
             }
             if (TargetSym != TargetSectionSymbols->begin()) {
diff --git a/llvm/unittests/ADT/STLExtrasTest.cpp b/llvm/unittests/ADT/STLExtrasTest.cpp
@@ -469,13 +469,14 @@ TEST(STLExtrasTest, to_address) {
   EXPECT_EQ(V1, to_address(V3));
 }
 
-TEST(STLExtrasTest, bsearch) {
+TEST(STLExtrasTest, partition_point) {
   std::vector<int> V = {1, 3, 5, 7, 9};
 
   // Range version.
-  EXPECT_EQ(V.begin() + 3, bsearch(V, [](unsigned X) { return X >= 7; }));
-  EXPECT_EQ(V.begin(), bsearch(V, [](unsigned X) { return X >= 1; }));
-  EXPECT_EQ(V.end(), bsearch(V, [](unsigned X) { return X >= 50; }));
+  EXPECT_EQ(V.begin() + 3,
+            partition_point(V, [](unsigned X) { return X < 7; }));
+  EXPECT_EQ(V.begin(), partition_point(V, [](unsigned X) { return X < 1; }));
+  EXPECT_EQ(V.end(), partition_point(V, [](unsigned X) { return X < 50; }));
 }
 
 } // namespace

Original file line number	Diff line number	Diff line change
`@@ -1268,8 +1268,8 @@ SectionPiece *MergeInputSection::getSectionPiece(uint64_t Offset) {`
`1268`	`1268`
`1269`	`1269`	`// If Offset is not at beginning of a section piece, it is not in the map.`
`1270`	`1270`	`// In that case we need to do a binary search of the original section piece vector.`
`1271`		`- auto It = llvm::bsearch(Pieces,`
`1272`		`- [=](SectionPiece P) { return Offset < P.InputOff; });`
	`1271`	`+ auto It = partition_point(`
	`1272`	`+ Pieces, [=](SectionPiece P) { return P.InputOff <= Offset; });`
`1273`	`1273`	`return &It[-1];`
`1274`	`1274`	`}`
`1275`	`1275`