// Find the summary entry for a desired percentile of counts.
static const ProfileSummaryEntry &getEntryForPercentile(SummaryEntryVector &DS,
uint64_t Percentile) {
- auto Compare = [](const ProfileSummaryEntry &Entry, uint64_t Percentile) {
- return Entry.Cutoff < Percentile;
- };
- auto It = std::lower_bound(DS.begin(), DS.end(), Percentile, Compare);
+ auto It = llvm::bsearch(DS, [=](const ProfileSummaryEntry &Entry) {
+ return Percentile <= Entry.Cutoff;
+ });
// The required percentile has to be <= one of the percentiles in the
// detailed summary.
if (It == DS.end())
// We are going to enumerate all the register mask slots contained in LI.
// Start with a binary search of RegMaskSlots to find a starting point.
- ArrayRef<SlotIndex>::iterator SlotI =
- std::lower_bound(Slots.begin(), Slots.end(), LiveI->start);
+ ArrayRef<SlotIndex>::iterator SlotI = llvm::lower_bound(Slots, LiveI->start);
ArrayRef<SlotIndex>::iterator SlotE = Slots.end();
// No slots in range, LI begins after the last call.
void updateRegMaskSlots() {
SmallVectorImpl<SlotIndex>::iterator RI =
- std::lower_bound(LIS.RegMaskSlots.begin(), LIS.RegMaskSlots.end(),
- OldIdx);
+ llvm::lower_bound(LIS.RegMaskSlots, OldIdx);
assert(RI != LIS.RegMaskSlots.end() && *RI == OldIdx.getRegSlot() &&
"No RegMask at OldIdx.");
*RI = NewIdx.getRegSlot();
for (SDep &PredEdge : SU->Preds) {
SUnit *PredSU = PredEdge.getSUnit();
- unsigned PredIndex =
- std::get<1>(*std::lower_bound(Indices.begin(), Indices.end(),
- std::make_pair(PredSU, 0), CompareKey));
+ unsigned PredIndex = std::get<1>(
+ *llvm::lower_bound(Indices, std::make_pair(PredSU, 0), CompareKey));
if (!PredSU->getInstr()->isPHI() && PredIndex < Index) {
PredBefore = true;
Pred = PredSU;
// return Indices.end().
if (SuccSU->isBoundaryNode())
continue;
- unsigned SuccIndex =
- std::get<1>(*std::lower_bound(Indices.begin(), Indices.end(),
- std::make_pair(SuccSU, 0), CompareKey));
+ unsigned SuccIndex = std::get<1>(
+ *llvm::lower_bound(Indices, std::make_pair(SuccSU, 0), CompareKey));
if (!SuccSU->getInstr()->isPHI() && SuccIndex < Index) {
SuccBefore = true;
Succ = SuccSU;
if (PredBefore && SuccBefore && !SU->getInstr()->isPHI()) {
// instructions in circuits are allowed to be scheduled
// after both a successor and predecessor.
- bool InCircuit = std::any_of(
- Circuits.begin(), Circuits.end(),
- [SU](const NodeSet &Circuit) { return Circuit.count(SU); });
+ bool InCircuit = llvm::any_of(
+ Circuits, [SU](const NodeSet &Circuit) { return Circuit.count(SU); });
if (InCircuit)
LLVM_DEBUG(dbgs() << "In a circuit, predecessor ";);
else {
}
FrameEntry *DWARFDebugFrame::getEntryAtOffset(uint64_t Offset) const {
- auto It =
- std::lower_bound(Entries.begin(), Entries.end(), Offset,
- [](const std::unique_ptr<FrameEntry> &E,
- uint64_t Offset) { return E->getOffset() < Offset; });
+ auto It = llvm::bsearch(Entries, [=](const std::unique_ptr<FrameEntry> &E) {
+ return Offset <= E->getOffset();
+ });
if (It != Entries.end() && (*It)->getOffset() == Offset)
return It->get();
return nullptr;
DataLayout::findAlignmentLowerBound(AlignTypeEnum AlignType,
uint32_t BitWidth) {
auto Pair = std::make_pair((unsigned)AlignType, BitWidth);
- return std::lower_bound(Alignments.begin(), Alignments.end(), Pair,
- [](const LayoutAlignElem &LHS,
- const std::pair<unsigned, uint32_t> &RHS) {
- return std::tie(LHS.AlignType, LHS.TypeBitWidth) <
- std::tie(RHS.first, RHS.second);
- });
+ return llvm::bsearch(Alignments, [=](const LayoutAlignElem &E) {
+ return Pair <= std::make_pair(E.AlignType, E.TypeBitWidth);
+ });
}
void
// 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 = std::lower_bound(Targets.begin(), Targets.end(), Target,
- [](const IntrinsicTargetInfo &TI,
- StringRef Target) { return TI.Name < Target; });
+ auto It = llvm::bsearch(Targets, [=](const IntrinsicTargetInfo &TI) {
+ return Target <= TI.Name;
+ });
// 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];
template <typename T>
static const T *Find(StringRef S, ArrayRef<T> A) {
// Binary search the array
- auto F = std::lower_bound(A.begin(), A.end(), S);
+ auto F = llvm::lower_bound(A, S);
// If not found then return NULL
if (F == A.end() || StringRef(F->Key) != S) return nullptr;
// Return the found array item
uint64_t InstrProfSymtab::getFunctionHashFromAddress(uint64_t Address) {
finalizeSymtab();
auto Result =
- std::lower_bound(AddrToMD5Map.begin(), AddrToMD5Map.end(), Address,
- [](const std::pair<uint64_t, uint64_t> &LHS,
- uint64_t RHS) { return LHS.first < RHS; });
+ llvm::bsearch(AddrToMD5Map, [=](std::pair<uint64_t, uint64_t> A) {
+ return Address <= A.first;
+ });
// 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
assert(PtrDiff >= 0 && static_cast<size_t>(PtrDiff) <= std::numeric_limits<T>::max());
T PtrOffset = static_cast<T>(PtrDiff);
- // std::lower_bound returns the first EOL offset that's not-less-than
- // PtrOffset, meaning the EOL that _ends the line_ that PtrOffset is on
- // (including if PtrOffset refers to the EOL itself). If there's no such
- // EOL, returns end().
- auto EOL = std::lower_bound(Offsets->begin(), Offsets->end(), PtrOffset);
-
- // Lines count from 1, so add 1 to the distance from the 0th line.
- return (1 + (EOL - Offsets->begin()));
+ // llvm::lower_bound gives the number of EOL before PtrOffset. Add 1 to get
+ // the line number.
+ return llvm::lower_bound(*Offsets, PtrOffset) - Offsets->begin() + 1;
}
SourceMgr::SrcBuffer::SrcBuffer(SourceMgr::SrcBuffer &&Other)
// Next, update WaterList. Specifically, we need to add NewMBB as having
// available water after it.
- water_iterator IP =
- std::lower_bound(WaterList.begin(), WaterList.end(), NewBB,
- CompareMBBNumbers);
+ water_iterator IP = llvm::lower_bound(WaterList, NewBB, CompareMBBNumbers);
WaterList.insert(IP, NewBB);
}
// available water after it (but not if it's already there, which happens
// when splitting before a conditional branch that is followed by an
// unconditional branch - in that case we want to insert NewBB).
- water_iterator IP =
- std::lower_bound(WaterList.begin(), WaterList.end(), OrigBB,
- CompareMBBNumbers);
+ water_iterator IP = llvm::lower_bound(WaterList, OrigBB, CompareMBBNumbers);
MachineBasicBlock* WaterBB = *IP;
if (WaterBB == OrigBB)
WaterList.insert(std::next(IP), NewBB);
}
#endif
- auto I = std::lower_bound(std::begin(NEONLdStTable),
- std::end(NEONLdStTable), Opcode);
+ auto I = llvm::lower_bound(NEONLdStTable, Opcode);
if (I != std::end(NEONLdStTable) && I->PseudoOpc == Opcode)
return I;
return nullptr;
} // end anonymous namespace
void OrderedRegisterList::insert(unsigned VR) {
- iterator L = std::lower_bound(Seq.begin(), Seq.end(), VR, Ord);
+ iterator L = llvm::lower_bound(Seq, VR, Ord);
if (L == Seq.end())
Seq.push_back(VR);
else
}
void OrderedRegisterList::remove(unsigned VR) {
- iterator L = std::lower_bound(Seq.begin(), Seq.end(), VR, Ord);
+ iterator L = llvm::lower_bound(Seq, VR, Ord);
if (L != Seq.end())
Seq.erase(L);
}
}
// one more look at list of intrinsics
const Mips16IntrinsicHelperType *Helper =
- std::lower_bound(std::begin(Mips16IntrinsicHelper),
- std::end(Mips16IntrinsicHelper), IntrinsicFind);
+ llvm::lower_bound(Mips16IntrinsicHelper, IntrinsicFind);
if (Helper != std::end(Mips16IntrinsicHelper) &&
*Helper == IntrinsicFind) {
Mips16HelperFunction = Helper->Helper;
// Next, update WaterList. Specifically, we need to add NewMBB as having
// available water after it.
- water_iterator IP =
- std::lower_bound(WaterList.begin(), WaterList.end(), NewBB,
- CompareMBBNumbers);
+ water_iterator IP = llvm::lower_bound(WaterList, NewBB, CompareMBBNumbers);
WaterList.insert(IP, NewBB);
}
// available water after it (but not if it's already there, which happens
// when splitting before a conditional branch that is followed by an
// unconditional branch - in that case we want to insert NewBB).
- water_iterator IP =
- std::lower_bound(WaterList.begin(), WaterList.end(), OrigBB,
- CompareMBBNumbers);
+ water_iterator IP = llvm::lower_bound(WaterList, OrigBB, CompareMBBNumbers);
MachineBasicBlock* WaterBB = *IP;
if (WaterBB == OrigBB)
WaterList.insert(std::next(IP), NewBB);
(Desc.TSFlags & X86II::VEX_L) ? makeArrayRef(X86EvexToVex256CompressTable)
: makeArrayRef(X86EvexToVex128CompressTable);
- auto I = std::lower_bound(Table.begin(), Table.end(), MI.getOpcode());
+ auto I = llvm::lower_bound(Table, MI.getOpcode());
if (I == Table.end() || I->EvexOpcode != MI.getOpcode())
return false;
}
static int Lookup(ArrayRef<TableEntry> Table, unsigned Opcode) {
- const TableEntry *I = std::lower_bound(Table.begin(), Table.end(), Opcode);
+ const TableEntry *I = llvm::lower_bound(Table, Opcode);
if (I != Table.end() && I->from == Opcode)
return I->to;
return -1;
copy_if(HiMask, std::back_inserter(HiInputs), [](int M) { return M >= 0; });
array_pod_sort(HiInputs.begin(), HiInputs.end());
HiInputs.erase(std::unique(HiInputs.begin(), HiInputs.end()), HiInputs.end());
- int NumLToL =
- std::lower_bound(LoInputs.begin(), LoInputs.end(), 4) - LoInputs.begin();
+ int NumLToL = llvm::lower_bound(LoInputs, 4) - LoInputs.begin();
int NumHToL = LoInputs.size() - NumLToL;
- int NumLToH =
- std::lower_bound(HiInputs.begin(), HiInputs.end(), 4) - HiInputs.begin();
+ int NumLToH = llvm::lower_bound(HiInputs, 4) - HiInputs.begin();
int NumHToH = HiInputs.size() - NumLToH;
MutableArrayRef<int> LToLInputs(LoInputs.data(), NumLToL);
MutableArrayRef<int> LToHInputs(HiInputs.data(), NumLToH);
// FMA 231 instructions have an opcode of 0xB6-0xBF
unsigned FormIndex = ((BaseOpcode - 0x90) >> 4) & 0x3;
- auto I = std::lower_bound(Table.begin(), Table.end(), Opcode,
- [FormIndex](const X86InstrFMA3Group &Group,
- unsigned Opcode) {
- return Group.Opcodes[FormIndex] < Opcode;
- });
+ auto I = llvm::bsearch(Table, [=](const X86InstrFMA3Group &Group) {
+ return Opcode <= Group.Opcodes[FormIndex];
+ });
assert(I != Table.end() && I->Opcodes[FormIndex] == Opcode &&
"Couldn't find FMA3 opcode!");
return I;
}
#endif
- const X86MemoryFoldTableEntry *Data = std::lower_bound(Table.begin(),
- Table.end(),
- RegOp);
+ const X86MemoryFoldTableEntry *Data = llvm::lower_bound(Table, RegOp);
if (Data != Table.end() && Data->KeyOp == RegOp &&
!(Data->Flags & TB_NO_FORWARD))
return Data;
const X86MemoryFoldTableEntry *
llvm::lookupUnfoldTable(unsigned MemOp) {
auto &Table = MemUnfoldTable->Table;
- auto I = std::lower_bound(Table.begin(), Table.end(), MemOp);
+ auto I = llvm::lower_bound(Table, MemOp);
if (I != Table.end() && I->KeyOp == MemOp)
return &*I;
return nullptr;
namespace detail {
template <typename C>
typename C::iterator addEntry(C &Container, StringRef InstallName) {
- auto I =
- std::lower_bound(std::begin(Container), std::end(Container), InstallName,
- [](const InterfaceFileRef &LHS, const StringRef &RHS) {
- return LHS.getInstallName() < RHS;
- });
+ auto I = llvm::bsearch(Container, [=](const InterfaceFileRef &O) {
+ return InstallName <= O.getInstallName();
+ });
if ((I != std::end(Container)) && !(InstallName < I->getInstallName()))
return I;
}
void InterfaceFile::addUUID(Architecture Arch, StringRef UUID) {
- auto I = std::lower_bound(UUIDs.begin(), UUIDs.end(), Arch,
- [](const std::pair<Architecture, std::string> &LHS,
- Architecture RHS) { return LHS.first < RHS; });
+ auto I =
+ llvm::bsearch(UUIDs, [=](const std::pair<Architecture, std::string> &O) {
+ return Arch <= O.first;
+ });
- if ((I != UUIDs.end()) && !(Arch < I->first)) {
+ if (I != UUIDs.end() && Arch == I->first) {
I->second = UUID;
return;
}
}
size_t blockToIndex(BasicBlock *BB) const {
- auto *I = std::lower_bound(V.begin(), V.end(), BB);
+ auto *I = llvm::lower_bound(V, BB);
assert(I != V.end() && *I == BB && "BasicBlockNumberng: Unknown block");
return I - V.begin();
}
for (pred_iterator PI = PB; PI != PE; ++PI) {
BasicBlock *P = *PI;
AvailablePredsTy::iterator I =
- std::lower_bound(AvailablePreds.begin(), AvailablePreds.end(),
- std::make_pair(P, (Value*)nullptr));
+ llvm::lower_bound(AvailablePreds, std::make_pair(P, (Value *)nullptr));
assert(I != AvailablePreds.end() && I->first == P &&
"Didn't find entry for predecessor!");
unsigned Alignment, Instruction *Inst) {
int64_t End = Start+Size;
- range_iterator I = std::lower_bound(Ranges.begin(), Ranges.end(), Start,
- [](const MemsetRange &LHS, int64_t RHS) { return LHS.End < RHS; });
+ range_iterator I = llvm::bsearch(
+ Ranges, [=](const MemsetRange &O) { return Start <= O.End; });
// 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
return V;
ValueEntry NewEntry = ValueEntry(getRank(V), V);
- Ops.insert(std::lower_bound(Ops.begin(), Ops.end(), NewEntry), NewEntry);
+ Ops.insert(llvm::lower_bound(Ops, NewEntry), NewEntry);
return nullptr;
}
return;
}
- auto InsertPoint = std::lower_bound(
- Rows.begin(), Rows.end(), Seq.front(),
- [](const DWARFDebugLine::Row &LHS, const DWARFDebugLine::Row &RHS) {
- return LHS.Address < RHS.Address;
- });
+ object::SectionedAddress Front = Seq.front().Address;
+ auto InsertPoint = llvm::bsearch(
+ 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
// described in patchLineTableForUnit() and delaying the end_sequene
// elimination to emitLineTableForUnit() we can get rid of all of them.
- if (InsertPoint != Rows.end() &&
- InsertPoint->Address == Seq.front().Address && InsertPoint->EndSequence) {
+ if (InsertPoint != Rows.end() && InsertPoint->Address == Front &&
+ InsertPoint->EndSequence) {
*InsertPoint = Seq.front();
Rows.insert(InsertPoint + 1, Seq.begin() + 1, Seq.end());
} else {
Top->ExtraData.TerminalDurations.end(), 0uLL);
{
auto E = std::make_pair(Top, TopSum);
- TopStacksBySum.insert(std::lower_bound(TopStacksBySum.begin(),
- TopStacksBySum.end(), E,
- greater_second),
- E);
+ TopStacksBySum.insert(
+ llvm::lower_bound(TopStacksBySum, E, greater_second), E);
if (TopStacksBySum.size() == 11)
TopStacksBySum.pop_back();
}
projects / llvm / commitdiff