Update prebuilt Clang to r416183b from Android.
https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef
clang 12.0.5 (based on r416183b) from build 7284624.
Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/llvm/Analysis/LoopInfo.h b/linux-x64/clang/include/llvm/Analysis/LoopInfo.h
index 98b3129..a5717ba 100644
--- a/linux-x64/clang/include/llvm/Analysis/LoopInfo.h
+++ b/linux-x64/clang/include/llvm/Analysis/LoopInfo.h
@@ -30,6 +30,9 @@
// instance. In particular, a Loop might be inside such a non-loop SCC, or a
// non-loop SCC might contain a sub-SCC which is a Loop.
//
+// For an overview of terminology used in this API (and thus all of our loop
+// analyses or transforms), see docs/LoopTerminology.rst.
+//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_LOOPINFO_H
@@ -57,7 +60,6 @@
class InductionDescriptor;
class MDNode;
class MemorySSAUpdater;
-class PHINode;
class ScalarEvolution;
class raw_ostream;
template <class N, bool IsPostDom> class DominatorTreeBase;
@@ -100,6 +102,14 @@
return D;
}
BlockT *getHeader() const { return getBlocks().front(); }
+ /// Return the parent loop if it exists or nullptr for top
+ /// level loops.
+
+ /// A loop is either top-level in a function (that is, it is not
+ /// contained in any other loop) or it is entirely enclosed in
+ /// some other loop.
+ /// If a loop is top-level, it has no parent, otherwise its
+ /// parent is the innermost loop in which it is enclosed.
LoopT *getParentLoop() const { return ParentLoop; }
/// This is a raw interface for bypassing addChildLoop.
@@ -145,7 +155,17 @@
iterator end() const { return getSubLoops().end(); }
reverse_iterator rbegin() const { return getSubLoops().rbegin(); }
reverse_iterator rend() const { return getSubLoops().rend(); }
- bool empty() const { return getSubLoops().empty(); }
+
+ // LoopInfo does not detect irreducible control flow, just natural
+ // loops. That is, it is possible that there is cyclic control
+ // flow within the "innermost loop" or around the "outermost
+ // loop".
+
+ /// Return true if the loop does not contain any (natural) loops.
+ bool isInnermost() const { return getSubLoops().empty(); }
+ /// Return true if the loop does not have a parent (natural) loop
+ // (i.e. it is outermost, which is the same as top-level).
+ bool isOutermost() const { return getParentLoop() == nullptr; }
/// Get a list of the basic blocks which make up this loop.
ArrayRef<BlockT *> getBlocks() const {
@@ -205,7 +225,7 @@
bool isLoopExiting(const BlockT *BB) const {
assert(!isInvalid() && "Loop not in a valid state!");
assert(contains(BB) && "Exiting block must be part of the loop");
- for (const auto &Succ : children<const BlockT *>(BB)) {
+ for (const auto *Succ : children<const BlockT *>(BB)) {
if (!contains(Succ))
return true;
}
@@ -270,14 +290,21 @@
/// Return all unique successor blocks of this loop.
/// These are the blocks _outside of the current loop_ which are branched to.
- /// This assumes that loop exits are in canonical form, i.e. all exits are
- /// dedicated exits.
void getUniqueExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
+ /// Return all unique successor blocks of this loop except successors from
+ /// Latch block are not considered. If the exit comes from Latch has also
+ /// non Latch predecessor in a loop it will be added to ExitBlocks.
+ /// These are the blocks _outside of the current loop_ which are branched to.
+ void getUniqueNonLatchExitBlocks(SmallVectorImpl<BlockT *> &ExitBlocks) const;
+
/// If getUniqueExitBlocks would return exactly one block, return that block.
/// Otherwise return null.
BlockT *getUniqueExitBlock() const;
+ /// Return true if this loop does not have any exit blocks.
+ bool hasNoExitBlocks() const;
+
/// Edge type.
typedef std::pair<BlockT *, BlockT *> Edge;
@@ -566,9 +593,9 @@
bool getIncomingAndBackEdge(BasicBlock *&Incoming,
BasicBlock *&Backedge) const;
- /// Below are some utilities to get loop bounds and induction variable, and
- /// check if a given phinode is an auxiliary induction variable, as well as
- /// checking if the loop is canonical.
+ /// Below are some utilities to get the loop guard, loop bounds and induction
+ /// variable, and to check if a given phinode is an auxiliary induction
+ /// variable, if the loop is guarded, and if the loop is canonical.
///
/// Here is an example:
/// \code
@@ -600,6 +627,9 @@
///
/// - getInductionVariable --> i_1
/// - isAuxiliaryInductionVariable(x) --> true if x == i_1
+ /// - getLoopGuardBranch()
+ /// --> `if (guardcmp) goto preheader; else goto afterloop`
+ /// - isGuarded() --> true
/// - isCanonical --> false
struct LoopBounds {
/// Return the LoopBounds object if
@@ -721,15 +751,52 @@
bool isAuxiliaryInductionVariable(PHINode &AuxIndVar,
ScalarEvolution &SE) const;
+ /// Return the loop guard branch, if it exists.
+ ///
+ /// This currently only works on simplified loop, as it requires a preheader
+ /// and a latch to identify the guard. It will work on loops of the form:
+ /// \code
+ /// GuardBB:
+ /// br cond1, Preheader, ExitSucc <== GuardBranch
+ /// Preheader:
+ /// br Header
+ /// Header:
+ /// ...
+ /// br Latch
+ /// Latch:
+ /// br cond2, Header, ExitBlock
+ /// ExitBlock:
+ /// br ExitSucc
+ /// ExitSucc:
+ /// \endcode
+ BranchInst *getLoopGuardBranch() const;
+
+ /// Return true iff the loop is
+ /// - in simplify rotated form, and
+ /// - guarded by a loop guard branch.
+ bool isGuarded() const { return (getLoopGuardBranch() != nullptr); }
+
+ /// Return true if the loop is in rotated form.
+ ///
+ /// This does not check if the loop was rotated by loop rotation, instead it
+ /// only checks if the loop is in rotated form (has a valid latch that exists
+ /// the loop).
+ bool isRotatedForm() const {
+ assert(!isInvalid() && "Loop not in a valid state!");
+ BasicBlock *Latch = getLoopLatch();
+ return Latch && isLoopExiting(Latch);
+ }
+
/// Return true if the loop induction variable starts at zero and increments
/// by one each time through the loop.
bool isCanonical(ScalarEvolution &SE) const;
/// Return true if the Loop is in LCSSA form.
- bool isLCSSAForm(DominatorTree &DT) const;
+ bool isLCSSAForm(const DominatorTree &DT) const;
/// Return true if this Loop and all inner subloops are in LCSSA form.
- bool isRecursivelyLCSSAForm(DominatorTree &DT, const LoopInfo &LI) const;
+ bool isRecursivelyLCSSAForm(const DominatorTree &DT,
+ const LoopInfo &LI) const;
/// Return true if the Loop is in the form that the LoopSimplify form
/// transforms loops to, which is sometimes called normal form.
@@ -776,6 +843,9 @@
/// unrolling pass is run more than once (which it generally is).
void setLoopAlreadyUnrolled();
+ /// Add llvm.loop.mustprogress to this loop's loop id metadata.
+ void setLoopMustProgress();
+
void dump() const;
void dumpVerbose() const;
@@ -908,13 +978,19 @@
return L && L->getHeader() == BB;
}
+ /// Return the top-level loops.
+ const std::vector<LoopT *> &getTopLevelLoops() const { return TopLevelLoops; }
+
+ /// Return the top-level loops.
+ std::vector<LoopT *> &getTopLevelLoopsVector() { return TopLevelLoops; }
+
/// This removes the specified top-level loop from this loop info object.
/// The loop is not deleted, as it will presumably be inserted into
/// another loop.
LoopT *removeLoop(iterator I) {
assert(I != end() && "Cannot remove end iterator!");
LoopT *L = *I;
- assert(!L->getParentLoop() && "Not a top-level loop!");
+ assert(L->isOutermost() && "Not a top-level loop!");
TopLevelLoops.erase(TopLevelLoops.begin() + (I - begin()));
return L;
}
@@ -942,7 +1018,7 @@
/// This adds the specified loop to the collection of top-level loops.
void addTopLevelLoop(LoopT *New) {
- assert(!New->getParentLoop() && "Loop already in subloop!");
+ assert(New->isOutermost() && "Loop already in subloop!");
TopLevelLoops.push_back(New);
}
@@ -1176,9 +1252,7 @@
public:
static char ID; // Pass identification, replacement for typeid
- LoopInfoWrapperPass() : FunctionPass(ID) {
- initializeLoopInfoWrapperPassPass(*PassRegistry::getPassRegistry());
- }
+ LoopInfoWrapperPass();
LoopInfo &getLoopInfo() { return LI; }
const LoopInfo &getLoopInfo() const { return LI; }