1 files changed, 49 insertions, 40 deletions

diff --git a/include/llvm/Analysis/DominanceFrontier.h b/include/llvm/Analysis/DominanceFrontier.h
index b566aeaf1fd6..a304dff18c79 100644
--- a/include/llvm/Analysis/DominanceFrontier.h
+++ b/include/llvm/Analysis/DominanceFrontier.h
@@ -18,40 +18,46 @@
 #ifndef LLVM_ANALYSIS_DOMINANCEFRONTIER_H
 #define LLVM_ANALYSIS_DOMINANCEFRONTIER_H
 
-#include "llvm/IR/Dominators.h"
+#include "llvm/ADT/GraphTraits.h"
 #include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/GenericDomTree.h"
+#include <cassert>
 #include <map>
 #include <set>
+#include <utility>
+#include <vector>
 
 namespace llvm {
 
+class Function;
+class raw_ostream;
+
 //===----------------------------------------------------------------------===//
 /// DominanceFrontierBase - Common base class for computing forward and inverse
 /// dominance frontiers for a function.
 ///
 template <class BlockT, bool IsPostDom>
 class DominanceFrontierBase {
- public:
-  typedef std::set<BlockT *> DomSetType;                // Dom set for a bb
-  typedef std::map<BlockT *, DomSetType> DomSetMapType; // Dom set map
+public:
+  using DomSetType = std::set<BlockT *>;                // Dom set for a bb
+  using DomSetMapType = std::map<BlockT *, DomSetType>; // Dom set map
 
 protected:
-  typedef GraphTraits<BlockT *> BlockTraits;
+  using BlockTraits = GraphTraits<BlockT *>;
 
   DomSetMapType Frontiers;
-  std::vector<BlockT *> Roots;
+  // Postdominators can have multiple roots.
+  SmallVector<BlockT *, IsPostDom ? 4 : 1> Roots;
   static constexpr bool IsPostDominators = IsPostDom;
 
- public:
-  DominanceFrontierBase() {}
+public:
+  DominanceFrontierBase() = default;
 
   /// getRoots - Return the root blocks of the current CFG.  This may include
   /// multiple blocks if we are computing post dominators.  For forward
   /// dominators, this will always be a single block (the entry node).
-  ///
-  inline const std::vector<BlockT *> &getRoots() const {
-    return Roots;
-  }
+  const SmallVectorImpl<BlockT *> &getRoots() const { return Roots; }
 
   BlockT *getRoot() const {
     assert(Roots.size() == 1 && "Should always have entry node!");
@@ -59,7 +65,6 @@ protected:
   }
 
   /// isPostDominator - Returns true if analysis based of postdoms
-  ///
   bool isPostDominator() const {
     return IsPostDominators;
   }
@@ -69,8 +74,9 @@ protected:
   }
 
   // Accessor interface:
-  typedef typename DomSetMapType::iterator iterator;
-  typedef typename DomSetMapType::const_iterator const_iterator;
+  using iterator = typename DomSetMapType::iterator;
+  using const_iterator = typename DomSetMapType::const_iterator;
+
   iterator begin() { return Frontiers.begin(); }
   const_iterator begin() const { return Frontiers.begin(); }
   iterator end() { return Frontiers.end(); }
@@ -115,19 +121,19 @@ protected:
 template <class BlockT>
 class ForwardDominanceFrontierBase
     : public DominanceFrontierBase<BlockT, false> {
- private:
-  typedef GraphTraits<BlockT *> BlockTraits;
+private:
+  using BlockTraits = GraphTraits<BlockT *>;
 
 public:
- typedef DomTreeBase<BlockT> DomTreeT;
- typedef DomTreeNodeBase<BlockT> DomTreeNodeT;
- typedef typename DominanceFrontierBase<BlockT, false>::DomSetType DomSetType;
-
- void analyze(DomTreeT &DT) {
-   this->Roots = DT.getRoots();
-   assert(this->Roots.size() == 1 &&
-          "Only one entry block for forward domfronts!");
-   calculate(DT, DT[this->Roots[0]]);
+  using DomTreeT = DomTreeBase<BlockT>;
+  using DomTreeNodeT = DomTreeNodeBase<BlockT>;
+  using DomSetType = typename DominanceFrontierBase<BlockT, false>::DomSetType;
+
+  void analyze(DomTreeT &DT) {
+    assert(DT.getRoots().size() == 1 &&
+           "Only one entry block for forward domfronts!");
+    this->Roots = {DT.getRoot()};
+    calculate(DT, DT[this->Roots[0]]);
   }
 
   const DomSetType &calculate(const DomTreeT &DT, const DomTreeNodeT *Node);
@@ -135,20 +141,21 @@ public:
 
 class DominanceFrontier : public ForwardDominanceFrontierBase<BasicBlock> {
 public:
- typedef DomTreeBase<BasicBlock> DomTreeT;
- typedef DomTreeNodeBase<BasicBlock> DomTreeNodeT;
- typedef DominanceFrontierBase<BasicBlock, false>::DomSetType DomSetType;
- typedef DominanceFrontierBase<BasicBlock, false>::iterator iterator;
- typedef DominanceFrontierBase<BasicBlock, false>::const_iterator
-     const_iterator;
-
- /// Handle invalidation explicitly.
- bool invalidate(Function &F, const PreservedAnalyses &PA,
-                 FunctionAnalysisManager::Invalidator &);
+  using DomTreeT = DomTreeBase<BasicBlock>;
+  using DomTreeNodeT = DomTreeNodeBase<BasicBlock>;
+  using DomSetType = DominanceFrontierBase<BasicBlock, false>::DomSetType;
+  using iterator = DominanceFrontierBase<BasicBlock, false>::iterator;
+  using const_iterator =
+      DominanceFrontierBase<BasicBlock, false>::const_iterator;
+
+  /// Handle invalidation explicitly.
+  bool invalidate(Function &F, const PreservedAnalyses &PA,
+                  FunctionAnalysisManager::Invalidator &);
 };
 
 class DominanceFrontierWrapperPass : public FunctionPass {
   DominanceFrontier DF;
+
 public:
   static char ID; // Pass ID, replacement for typeid
 
@@ -176,11 +183,12 @@ extern template class ForwardDominanceFrontierBase<BasicBlock>;
 class DominanceFrontierAnalysis
     : public AnalysisInfoMixin<DominanceFrontierAnalysis> {
   friend AnalysisInfoMixin<DominanceFrontierAnalysis>;
+
   static AnalysisKey Key;
 
 public:
-  /// \brief Provide the result typedef for this analysis pass.
-  typedef DominanceFrontier Result;
+  /// \brief Provide the result type for this analysis pass.
+  using Result = DominanceFrontier;
 
   /// \brief Run the analysis pass over a function and produce a dominator tree.
   DominanceFrontier run(Function &F, FunctionAnalysisManager &AM);
@@ -193,9 +201,10 @@ class DominanceFrontierPrinterPass
 
 public:
   explicit DominanceFrontierPrinterPass(raw_ostream &OS);
+
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 };
 
-} // End llvm namespace
+} // end namespace llvm
 
-#endif
+#endif // LLVM_ANALYSIS_DOMINANCEFRONTIER_H