LLVM: include/llvm/Support/GenericLoopInfoImpl.h Source File (original) (raw)

1

2

3

4

5

6

7

8

9

10

11

12

13

14#ifndef LLVM_SUPPORT_GENERICLOOPINFOIMPL_H

15#define LLVM_SUPPORT_GENERICLOOPINFOIMPL_H

16

22

23namespace llvm {

24

25

26

27

28

29

30

31

32template <class BlockT, class LoopT>

35 assert(!isInvalid() && "Loop not in a valid state!");

36 for (const auto BB : blocks())

37 for (auto *Succ : children<BlockT *>(BB))

39

41 break;

42 }

43}

44

45

46

47template <class BlockT, class LoopT>

49 assert(!isInvalid() && "Loop not in a valid state!");

50 auto notInLoop = [&](BlockT *BB) { return contains(BB); };

51 auto isExitBlock = [&](BlockT *BB, bool AllowRepeats) -> BlockT * {

52 assert(!AllowRepeats && "Unexpected parameter value.");

53

54 return any_of(children<BlockT *>(BB), notInLoop) ? BB : nullptr;

55 };

56

58}

59

60

61

62

63template <class BlockT, class LoopT>

66 assert(!isInvalid() && "Loop not in a valid state!");

67 for (const auto BB : blocks())

68 for (auto *Succ : children<BlockT *>(BB))

70

72}

73

74

75

76template <class BlockT, class LoopT>

78 bool Unique) {

79 assert(!L->isInvalid() && "Loop not in a valid state!");

80 auto notInLoop = [&](BlockT *BB,

81 bool AllowRepeats) -> std::pair<BlockT *, bool> {

82 assert(AllowRepeats == Unique && "Unexpected parameter value.");

83 return {!L->contains(BB) ? BB : nullptr, false};

84 };

85 auto singleExitBlock = [&](BlockT *BB,

86 bool AllowRepeats) -> std::pair<BlockT *, bool> {

87 assert(AllowRepeats == Unique && "Unexpected parameter value.");

88 return find_singleton_nested(children<BlockT *>(BB), notInLoop,

89 AllowRepeats);

90 };

91 return find_singleton_nested(L->blocks(), singleExitBlock, Unique);

92}

93

94template <class BlockT, class LoopT>

97 if (RC.second)

98

99 return false;

100

101 return !RC.first;

102}

103

104

105

106template <class BlockT, class LoopT>

109}

110

111template <class BlockT, class LoopT>

113

114

116 getUniqueExitBlocks(UniqueExitBlocks);

117 for (BlockT *EB : UniqueExitBlocks)

118 for (BlockT *Predecessor : inverse_children<BlockT *>(EB))

120 return false;

121

122 return true;

123}

124

125

126

127template <class BlockT, class LoopT, typename PredicateT>

131 assert(!L->isInvalid() && "Loop not in a valid state!");

134 for (BlockT *BB : Filtered)

135 for (BlockT *Successor : children<BlockT *>(BB))

139}

140

141template <class BlockT, class LoopT>

145 [](const BlockT *BB) { return true; });

146}

147

148template <class BlockT, class LoopT>

151 const BlockT *Latch = getLoopLatch();

152 assert(Latch && "Latch block must exists");

154 [Latch](const BlockT *BB) { return BB != Latch; });

155}

156

157template <class BlockT, class LoopT>

160}

161

162template <class BlockT, class LoopT>

164 BlockT *Latch = getLoopLatch();

165 assert(Latch && "Latch block must exists");

166 auto IsExitBlock = [this](BlockT *BB, bool AllowRepeats) -> BlockT * {

167 assert(!AllowRepeats && "Unexpected parameter value.");

168 return contains(BB) ? BB : nullptr;

169 };

170 return find_singleton(children<BlockT *>(Latch), IsExitBlock);

171}

172

173

174template <class BlockT, class LoopT>

177 assert(!isInvalid() && "Loop not in a valid state!");

178 for (const auto BB : blocks())

179 for (auto *Succ : children<BlockT *>(BB))

181

183}

184

186template

188

189template

191

192

193

196 return Block->isLegalToHoistInto();

197 return false;

198}

199}

200

201

202

203

204

205

206

207

208

209template <class BlockT, class LoopT>

211 assert(!isInvalid() && "Loop not in a valid state!");

212

213 BlockT *Out = getLoopPredecessor();

214 if (!Out)

215 return nullptr;

216

217

219 return nullptr;

220

221

223 return nullptr;

224

225

226 return Out;

227}

228

229

230

231

232

233

234template <class BlockT, class LoopT>

236 assert(!isInvalid() && "Loop not in a valid state!");

237

238 BlockT *Out = nullptr;

239

240

241 BlockT *Header = getHeader();

242 for (const auto Pred : inverse_children<BlockT *>(Header)) {

243 if (contains(Pred)) {

244 if (Out && Out != Pred)

245 return nullptr;

246 Out = Pred;

247 }

248 }

249

250 return Out;

251}

252

253

254

255template <class BlockT, class LoopT>

257 assert(!isInvalid() && "Loop not in a valid state!");

258 BlockT *Header = getHeader();

259 BlockT *Latch = nullptr;

260 for (const auto Pred : inverse_children<BlockT *>(Header)) {

262 if (Latch)

263 return nullptr;

264 Latch = Pred;

266 }

267

268 return Latch;

270

271

272

274

275

276

277

278

279

280

281template <class BlockT, class LoopT>

284 assert(!isInvalid() && "Loop not in a valid state!");

285#ifndef NDEBUG

286 if (Blocks.empty()) {

287 auto SameHeader = LIB[getHeader()];

288 assert(contains(SameHeader) && getHeader() == SameHeader->getHeader() &&

289 "Incorrect LI specified for this loop!");

290 }

292 assert(NewBB && "Cannot add a null basic block to the loop!");

293 assert(!LIB[NewBB] && "BasicBlock already in the loop!");

294

295 LoopT *L = static_cast<LoopT *>(this);

296

297

298 LIB.BBMap[NewBB] = L;

300

301 while (L) {

302 L->addBlockEntry(NewBB);

303 L = L->getParentLoop();

304 }

305}

306

307

308

309

310

311template <class BlockT, class LoopT>

313 LoopT *NewChild) {

314 assert(!isInvalid() && "Loop not in a valid state!");

315 assert(OldChild->ParentLoop == this && "This loop is already broken!");

316 assert(!NewChild->ParentLoop && "NewChild already has a parent!");

317 typename std::vector<LoopT *>::iterator I = find(SubLoops, OldChild);

318 assert(I != SubLoops.end() && "OldChild not in loop!");

319 *I = NewChild;

320 OldChild->ParentLoop = nullptr;

321 NewChild->ParentLoop = static_cast<LoopT *>(this);

323

324

325template <class BlockT, class LoopT>

327 assert(!isInvalid() && "Loop not in a valid state!");

328#ifndef NDEBUG

329 assert(Blocks.empty() && "Loop header is missing");

330

331

333 getExitBlocks(ExitBBs);

336

337

339

340

341 for (BlockT *BB : depth_first_ext(getHeader(), VisitSet)) {

343 [&](BlockT *B) { return contains(B); }) &&

344 "Loop block has no in-loop successors!");

345

347 [&](BlockT *B) { return contains(B); }) &&

348 "Loop block has no in-loop predecessors!");

349

351 for (BlockT *B : inverse_children<BlockT *>(BB))

354

355 if (BB == getHeader()) {

356 assert(!OutsideLoopPreds.empty() && "Loop is unreachable!");

357 } else if (!OutsideLoopPreds.empty()) {

358

359

360

361 BlockT *EntryBB = &BB->getParent()->front();

363 for (unsigned i = 0, e = OutsideLoopPreds.size(); i != e; ++i)

364 assert(CB != OutsideLoopPreds[i] &&

365 "Loop has multiple entry points!");

366 }

368 "Loop contains function entry block!");

369

370 VisitedBBs.insert(BB);

371 }

372

373 if (VisitedBBs.size() != getNumBlocks()) {

374 dbgs() << "The following blocks are unreachable in the loop: ";

375 for (auto *BB : Blocks) {

376 if (!VisitedBBs.count(BB)) {

377 dbgs() << *BB << "\n";

378 }

379 }

380 assert(false && "Unreachable block in loop");

382

383

384 for (iterator I = begin(), E = end(); I != E; ++I)

385

386 for (block_iterator BI = (*I)->block_begin(), BE = (*I)->block_end();

387 BI != BE; ++BI) {

389 "Loop does not contain all the blocks of a subloop!");

390 }

391

392

393 if (ParentLoop) {

395 "Loop is not a subloop of its parent!");

396 }

397#endif

398}

399

400

401template <class BlockT, class LoopT>

404 assert(!isInvalid() && "Loop not in a valid state!");

405 Loops->insert(static_cast<const LoopT *>(this));

406

407 verifyLoop();

408

409 for (iterator I = begin(), E = end(); I != E; ++I)

410 (*I)->verifyLoopNest(Loops);

411}

412

413template <class BlockT, class LoopT>

415 bool PrintNested, unsigned Depth) const {

417 if (static_cast<const LoopT *>(this)->isAnnotatedParallel())

418 OS << "Parallel ";

419 OS << "Loop at depth " << getLoopDepth() << " containing: ";

420

421 BlockT *H = getHeader();

422 for (unsigned i = 0; i < getBlocks().size(); ++i) {

423 BlockT *BB = getBlocks()[i];

425 if (i)

426 OS << ",";

427 BB->printAsOperand(OS, false);

428 } else

429 OS << "\n";

430

431 if (BB == H)

432 OS << "

";

433 if (isLoopLatch(BB))

434 OS << "";

435 if (isLoopExiting(BB))

436 OS << "";

438 BB->print(OS);

439 }

440

441 if (PrintNested) {

442 OS << "\n";

443

444 for (iterator I = begin(), E = end(); I != E; ++I)

445 (*I)->print(OS, false, PrintNested, Depth + 2);

446 }

447}

448

449

450

451

452

453

454

455

456

457template <class BlockT, class LoopT>

462

463 unsigned NumBlocks = 0;

464 unsigned NumSubloops = 0;

465

466

467 std::vector<BlockT *> ReverseCFGWorklist(Backedges.begin(), Backedges.end());

468 while (!ReverseCFGWorklist.empty()) {

469 BlockT *PredBB = ReverseCFGWorklist.back();

470 ReverseCFGWorklist.pop_back();

471

472 LoopT *Subloop = LI->getLoopFor(PredBB);

473 if (!Subloop) {

475 continue;

476

477

479 ++NumBlocks;

480 if (PredBB == L->getHeader())

481 continue;

482

483 ReverseCFGWorklist.insert(ReverseCFGWorklist.end(),

484 InvBlockTraits::child_begin(PredBB),

485 InvBlockTraits::child_end(PredBB));

486 } else {

487

488 Subloop = Subloop->getOutermostLoop();

489

490

491 if (Subloop == L)

492 continue;

493

494

495 Subloop->setParentLoop(L);

496 ++NumSubloops;

497 NumBlocks += Subloop->getBlocksVector().capacity();

498 PredBB = Subloop->getHeader();

499

500

501

502

503 for (const auto Pred : inverse_children<BlockT *>(PredBB)) {

505 ReverseCFGWorklist.push_back(Pred);

506 }

507 }

508 }

509 L->getSubLoopsVector().reserve(NumSubloops);

510 L->reserveBlocks(NumBlocks);

511}

512

513

516 typedef typename BlockTraits::ChildIteratorType SuccIterTy;

517

519

520public:

522

523 void traverse(BlockT *EntryBlock);

524

525protected:

527};

528

529

530template <class BlockT, class LoopT>

532 for (BlockT *BB : post_order(EntryBlock))

533 insertIntoLoop(BB);

534}

535

536

537

538

539template <class BlockT, class LoopT>

542 if (Subloop && Block == Subloop->getHeader()) {

543

544

545 if (!Subloop->isOutermost())

546 Subloop->getParentLoop()->getSubLoopsVector().push_back(Subloop);

547 else

549

550

551

552 Subloop->reverseBlock(1);

553 std::reverse(Subloop->getSubLoopsVector().begin(),

554 Subloop->getSubLoopsVector().end());

555

556 Subloop = Subloop->getParentLoop();

557 }

558 for (; Subloop; Subloop = Subloop->getParentLoop())

559 Subloop->addBlockEntry(Block);

560}

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576template <class BlockT, class LoopT>

578

580 for (auto DomNode : post_order(DomRoot)) {

581

582 BlockT *Header = DomNode->getBlock();

584

585

586 for (const auto Backedge : inverse_children<BlockT *>(Header)) {

587

589 if (BackedgeNode && DomTree.dominates(DomNode, BackedgeNode))

591 }

592

593 if (!Backedges.empty()) {

594 LoopT *L = AllocateLoop(Header);

596 }

597 }

598

599

600 PopulateLoopsDFS<BlockT, LoopT> DFS(this);

601 DFS.traverse(DomRoot->getBlock());

603

604template <class BlockT, class LoopT>

608

609

610

611

612

613 for (LoopT *RootL : reverse(*this)) {

614 auto PreOrderLoopsInRootL = RootL->getLoopsInPreorder();

615 PreOrderLoops.append(PreOrderLoopsInRootL.begin(),

616 PreOrderLoopsInRootL.end());

617 }

618

619 return PreOrderLoops;

620}

621

622template <class BlockT, class LoopT>

626

627

628

629

630

631 for (LoopT *RootL : *this) {

633 "Must start with an empty preorder walk worklist.");

634 PreOrderWorklist.push_back(RootL);

635 do {

637

638

639 PreOrderWorklist.append(L->begin(), L->end());

641 } while (!PreOrderWorklist.empty());

642 }

643

644 return PreOrderLoops;

645}

646

647

648template <class BlockT, class LoopT>

650 for (unsigned i = 0; i < TopLevelLoops.size(); ++i)

651 TopLevelLoops[i]->print(OS);

652#if 0

654 E = BBMap.end(); I != E; ++I)

655 OS << "BB '" << I->first->getName() << "' level = "

656 << I->second->getLoopDepth() << "\n";

657#endif

658}

659

660template

664 return BB1 == BB2;

665}

666

667template <class BlockT, class LoopT>

670 const LoopT &L) {

671 LoopHeaders[L.getHeader()] = &L;

672 for (LoopT *SL : L)

674}

675

676#ifndef NDEBUG

677template <class BlockT, class LoopT>

678static void compareLoops(const LoopT *L, const LoopT *OtherL,

680 BlockT *H = L->getHeader();

681 BlockT *OtherH = OtherL->getHeader();

683 "Mismatched headers even though found in the same map entry!");

684

685 assert(L->getLoopDepth() == OtherL->getLoopDepth() &&

686 "Mismatched loop depth!");

687 const LoopT *ParentL = L, *OtherParentL = OtherL;

688 do {

689 assert(ParentL->getHeader() == OtherParentL->getHeader() &&

690 "Mismatched parent loop headers!");

691 ParentL = ParentL->getParentLoop();

692 OtherParentL = OtherParentL->getParentLoop();

693 } while (ParentL);

694

695 for (const LoopT *SubL : *L) {

696 BlockT *SubH = SubL->getHeader();

697 const LoopT *OtherSubL = OtherLoopHeaders.lookup(SubH);

698 assert(OtherSubL && "Inner loop is missing in computed loop info!");

699 OtherLoopHeaders.erase(SubH);

700 compareLoops(SubL, OtherSubL, OtherLoopHeaders);

701 }

702

703 std::vector<BlockT *> BBs = L->getBlocks();

704 std::vector<BlockT *> OtherBBs = OtherL->getBlocks();

706 "Mismatched basic blocks in the loops!");

707

710 OtherL->getBlocksSet();

713 "Mismatched basic blocks in BlocksSets!");

714}

715#endif

716

717template <class BlockT, class LoopT>

721 for (iterator I = begin(), E = end(); I != E; ++I) {

722 assert((*I)->isOutermost() && "Top-level loop has a parent!");

723 (*I)->verifyLoopNest(&Loops);

724 }

725

726

727#ifndef NDEBUG

728 for (auto &Entry : BBMap) {

729 const BlockT *BB = Entry.first;

730 LoopT *L = Entry.second;

731 assert(Loops.count(L) && "orphaned loop");

732 assert(L->contains(BB) && "orphaned block");

733 for (LoopT *ChildLoop : *L)

734 assert(!ChildLoop->contains(BB) &&

735 "BBMap should point to the innermost loop containing BB");

736 }

737

738

740 OtherLI.analyze(DomTree);

741

742

743

744

746 for (LoopT *L : OtherLI)

748

749

750

751

752 for (LoopT *L : *this) {

753 BlockT *Header = L->getHeader();

754 const LoopT *OtherL = OtherLoopHeaders.lookup(Header);

755 assert(OtherL && "Top level loop is missing in computed loop info!");

756

757 OtherLoopHeaders.erase(Header);

758

760 }

761

762

763

764 if (!OtherLoopHeaders.empty()) {

765 for (const auto &HeaderAndLoop : OtherLoopHeaders)

766 dbgs() << "Found new loop: " << *HeaderAndLoop.second << "\n";

767 llvm_unreachable("Found new loops when recomputing LoopInfo!");

768 }

769#endif

770}

771

772}

773

774#endif

static const Function * getParent(const Value *V)

bbsections Prepares for basic block by splitting functions into clusters of basic blocks

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

This file builds on the ADT/GraphTraits.h file to build generic depth first graph iterator.

DenseMap< Block *, BlockRelaxAux > Blocks

static bool isExitBlock(BasicBlock *BB, const SmallVectorImpl< BasicBlock * > &ExitBlocks)

Return true if the specified block is in the list.

This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)

This file defines generic set operations that may be used on set's of different types,...

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

ValueT lookup(const_arg_type_t< KeyT > Val) const

lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...

bool erase(const KeyT &Val)

Implements a dense probed hash-table based set.

Base class for the actual dominator tree node.

Core dominator tree base class.

DomTreeNodeBase< NodeT > * getRootNode()

getRootNode - This returns the entry node for the CFG of the function.

bool dominates(const DomTreeNodeBase< NodeT > *A, const DomTreeNodeBase< NodeT > *B) const

dominates - Returns true iff A dominates B.

bool isReachableFromEntry(const NodeT *A) const

isReachableFromEntry - Return true if A is dominated by the entry block of the function containing it...

DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const

getNode - return the (Post)DominatorTree node for the specified basic block.

Instances of this class are used to represent loops that are detected in the flow graph.

BlockT * getLoopLatch() const

If there is a single latch block for this loop, return it.

void getExitBlocks(SmallVectorImpl< BlockT * > &ExitBlocks) const

Return all of the successor blocks of this loop.

void verifyLoop() const

Verify loop structure.

void verifyLoopNest(DenseSet< const LoopT * > *Loops) const

Verify loop structure of this loop and all nested loops.

BlockT * getUniqueLatchExitBlock() const

Return the unique exit block for the latch, or null if there are multiple different exit blocks or th...

void getExitingBlocks(SmallVectorImpl< BlockT * > &ExitingBlocks) const

Return all blocks inside the loop that have successors outside of the loop.

void print(raw_ostream &OS, bool Verbose=false, bool PrintNested=true, unsigned Depth=0) const

Print loop with all the BBs inside it.

void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase< BlockT, LoopT > &LI)

This method is used by other analyses to update loop information.

std::vector< LoopT * >::const_iterator iterator

BlockT * getLoopPredecessor() const

If the given loop's header has exactly one unique predecessor outside the loop, return it.

void getExitEdges(SmallVectorImpl< Edge > &ExitEdges) const

Return all pairs of (inside_block,outside_block).

BlockT * getExitBlock() const

If getExitBlocks would return exactly one block, return that block.

bool hasNoExitBlocks() const

Return true if this loop does not have any exit blocks.

void replaceChildLoopWith(LoopT *OldChild, LoopT *NewChild)

This is used when splitting loops up.

BlockT * getLoopPreheader() const

If there is a preheader for this loop, return it.

BlockT * getExitingBlock() const

If getExitingBlocks would return exactly one block, return that block.

void getUniqueExitBlocks(SmallVectorImpl< BlockT * > &ExitBlocks) const

Return all unique successor blocks of this loop.

bool hasDedicatedExits() const

Return true if no exit block for the loop has a predecessor that is outside the loop.

void getUniqueNonLatchExitBlocks(SmallVectorImpl< BlockT * > &ExitBlocks) const

Return all unique successor blocks of this loop except successors from Latch block are not considered...

BlockT * getUniqueExitBlock() const

If getUniqueExitBlocks would return exactly one block, return that block.

This class builds and contains all of the top-level loop structures in the specified function.

void verify(const DominatorTreeBase< BlockT, false > &DomTree) const

void addTopLevelLoop(LoopT *New)

This adds the specified loop to the collection of top-level loops.

void analyze(const DominatorTreeBase< BlockT, false > &DomTree)

Create the loop forest using a stable algorithm.

SmallVector< LoopT *, 4 > getLoopsInReverseSiblingPreorder() const

Return all of the loops in the function in preorder across the loop nests, with siblings in reverse p...

void print(raw_ostream &OS) const

SmallVector< LoopT *, 4 > getLoopsInPreorder() const

Return all of the loops in the function in preorder across the loop nests, with siblings in forward p...

void changeLoopFor(BlockT *BB, LoopT *L)

Change the top-level loop that contains BB to the specified loop.

LoopT * getLoopFor(const BlockT *BB) const

Return the inner most loop that BB lives in.

std::vector< LoopT * >::const_iterator iterator

iterator/begin/end - The interface to the top-level loops in the current function.

Populate all loop data in a stable order during a single forward DFS.

void traverse(BlockT *EntryBlock)

Top-level driver for the forward DFS within the loop.

PopulateLoopsDFS(LoopInfoBase< BlockT, LoopT > *li)

void insertIntoLoop(BlockT *Block)

Add a single Block to its ancestor loops in PostOrder.

A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...

size_type count(ConstPtrType Ptr) const

count - Return 1 if the specified pointer is in the set, 0 otherwise.

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

reference emplace_back(ArgTypes &&... Args)

void append(ItTy in_start, ItTy in_end)

Add the specified range to the end of the SmallVector.

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

This class implements an extremely fast bulk output stream that can only output to a stream.

raw_ostream & indent(unsigned NumSpaces)

indent - Insert 'NumSpaces' spaces.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

decltype(&BlockT::isLegalToHoistInto) has_hoist_check

llvm::is_detected< has_hoist_check, BlockT > detect_has_hoist_check

bool isLegalToHoistInto(BlockT *Block)

SFINAE functions that dispatch to the isLegalToHoistInto member function or return false,...

This is an optimization pass for GlobalISel generic memory operations.

iterator_range< df_ext_iterator< T, SetTy > > depth_first_ext(const T &G, SetTy &S)

auto find(R &&Range, const T &Val)

Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.

static void compareLoops(const LoopT *L, const LoopT *OtherL, DenseMap< BlockT *, const LoopT * > &OtherLoopHeaders)

bool set_is_subset(const S1Ty &S1, const S2Ty &S2)

set_is_subset(A, B) - Return true iff A in B

iterator_range< po_iterator< T > > post_order(const T &G)

Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr)

typename detail::detector< void, Op, Args... >::value_t is_detected

Detects if a given trait holds for some set of arguments 'Args'.

bool any_of(R &&range, UnaryPredicate P)

Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.

auto reverse(ContainerTy &&C)

void sort(IteratorTy Start, IteratorTy End)

raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

bool hasSingleElement(ContainerTy &&C)

Returns true if the given container only contains a single element.

iterator_range< filter_iterator< detail::IterOfRange< RangeT >, PredicateT > > make_filter_range(RangeT &&Range, PredicateT Pred)

Convenience function that takes a range of elements and a predicate, and return a new filter_iterator...

std::pair< BlockT *, bool > getExitBlockHelper(const LoopBase< BlockT, LoopT > *L, bool Unique)

getExitBlock - If getExitBlocks would return exactly one block, return that block.

void addInnerLoopsToHeadersMap(DenseMap< BlockT *, const LoopT * > &LoopHeaders, const LoopInfoBase< BlockT, LoopT > &LI, const LoopT &L)

void getUniqueExitBlocksHelper(const LoopT *L, SmallVectorImpl< BlockT * > &ExitBlocks, PredicateT Pred)

bool is_contained(R &&Range, const E &Element)

Returns true if Element is found in Range.

bool compareVectors(std::vector< T > &BB1, std::vector< T > &BB2)

iterator_range< df_iterator< T > > depth_first(const T &G)

static void discoverAndMapSubloop(LoopT *L, ArrayRef< BlockT * > Backedges, LoopInfoBase< BlockT, LoopT > *LI, const DomTreeBase< BlockT > &DomTree)

Stable LoopInfo Analysis - Build a loop tree using stable iterators so the result does / not depend o...

std::pair< iterator, bool > insert(NodeRef N)