1 files changed, 65 insertions, 65 deletions
diff --git a/contrib/llvm/include/llvm/CodeGen/MachineRegionInfo.h b/contrib/llvm/include/llvm/CodeGen/MachineRegionInfo.h
index 21f847c..8394b58 100644
--- a/contrib/llvm/include/llvm/CodeGen/MachineRegionInfo.h
+++ b/contrib/llvm/include/llvm/CodeGen/MachineRegionInfo.h
@@ -10,83 +10,77 @@
 #ifndef LLVM_CODEGEN_MACHINEREGIONINFO_H
 #define LLVM_CODEGEN_MACHINEREGIONINFO_H
 
+#include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Analysis/RegionIterator.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineDominanceFrontier.h"
 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
-
+#include <cassert>
 
 namespace llvm {
 
-class MachineDominatorTree;
 struct MachinePostDominatorTree;
 class MachineRegion;
 class MachineRegionNode;
 class MachineRegionInfo;
 
-template<>
-struct RegionTraits<MachineFunction> {
-  typedef MachineFunction FuncT;
-  typedef MachineBasicBlock BlockT;
-  typedef MachineRegion RegionT;
-  typedef MachineRegionNode RegionNodeT;
-  typedef MachineRegionInfo RegionInfoT;
-  typedef MachineDominatorTree DomTreeT;
-  typedef MachineDomTreeNode DomTreeNodeT;
-  typedef MachinePostDominatorTree PostDomTreeT;
-  typedef MachineDominanceFrontier DomFrontierT;
-  typedef MachineInstr InstT;
-  typedef MachineLoop LoopT;
-  typedef MachineLoopInfo LoopInfoT;
+template <> struct RegionTraits<MachineFunction> {
+  using FuncT = MachineFunction;
+  using BlockT = MachineBasicBlock;
+  using RegionT = MachineRegion;
+  using RegionNodeT = MachineRegionNode;
+  using RegionInfoT = MachineRegionInfo;
+  using DomTreeT = MachineDominatorTree;
+  using DomTreeNodeT = MachineDomTreeNode;
+  using PostDomTreeT = MachinePostDominatorTree;
+  using DomFrontierT = MachineDominanceFrontier;
+  using InstT = MachineInstr;
+  using LoopT = MachineLoop;
+  using LoopInfoT = MachineLoopInfo;
 
   static unsigned getNumSuccessors(MachineBasicBlock *BB) {
     return BB->succ_size();
   }
 };
 
-
 class MachineRegionNode : public RegionNodeBase<RegionTraits<MachineFunction>> {
 public:
-  inline MachineRegionNode(MachineRegion *Parent,
-                           MachineBasicBlock *Entry,
+  inline MachineRegionNode(MachineRegion *Parent, MachineBasicBlock *Entry,
                            bool isSubRegion = false)
-    : RegionNodeBase<RegionTraits<MachineFunction>>(Parent, Entry, isSubRegion) {
-
-  }
+      : RegionNodeBase<RegionTraits<MachineFunction>>(Parent, Entry,
+                                                      isSubRegion) {}
 
   bool operator==(const MachineRegion &RN) const {
-    return this == reinterpret_cast<const MachineRegionNode*>(&RN);
+    return this == reinterpret_cast<const MachineRegionNode *>(&RN);
   }
 };
 
 class MachineRegion : public RegionBase<RegionTraits<MachineFunction>> {
 public:
   MachineRegion(MachineBasicBlock *Entry, MachineBasicBlock *Exit,
-                MachineRegionInfo* RI,
-                MachineDominatorTree *DT, MachineRegion *Parent = nullptr);
+                MachineRegionInfo *RI, MachineDominatorTree *DT,
+                MachineRegion *Parent = nullptr);
   ~MachineRegion();
 
   bool operator==(const MachineRegionNode &RN) const {
-    return &RN == reinterpret_cast<const MachineRegionNode*>(this);
+    return &RN == reinterpret_cast<const MachineRegionNode *>(this);
   }
 };
 
 class MachineRegionInfo : public RegionInfoBase<RegionTraits<MachineFunction>> {
 public:
   explicit MachineRegionInfo();
-
   ~MachineRegionInfo() override;
 
   // updateStatistics - Update statistic about created regions.
   void updateStatistics(MachineRegion *R) final;
 
-  void recalculate(MachineFunction &F,
-                   MachineDominatorTree *DT,
-                   MachinePostDominatorTree *PDT,
-                   MachineDominanceFrontier *DF);
+  void recalculate(MachineFunction &F, MachineDominatorTree *DT,
+                   MachinePostDominatorTree *PDT, MachineDominanceFrontier *DF);
 };
 
 class MachineRegionInfoPass : public MachineFunctionPass {
@@ -94,17 +88,13 @@ class MachineRegionInfoPass : public MachineFunctionPass {
 
 public:
   static char ID;
-  explicit MachineRegionInfoPass();
 
+  explicit MachineRegionInfoPass();
   ~MachineRegionInfoPass() override;
 
-  MachineRegionInfo &getRegionInfo() {
-    return RI;
-  }
+  MachineRegionInfo &getRegionInfo() { return RI; }
 
-  const MachineRegionInfo &getRegionInfo() const {
-    return RI;
-  }
+  const MachineRegionInfo &getRegionInfo() const { return RI; }
 
   /// @name MachineFunctionPass interface
   //@{
@@ -117,66 +107,76 @@ public:
   //@}
 };
 
-
 template <>
 template <>
-inline MachineBasicBlock* RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>() const {
+inline MachineBasicBlock *
+RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineBasicBlock>()
+    const {
   assert(!isSubRegion() && "This is not a MachineBasicBlock RegionNode!");
   return getEntry();
 }
 
-template<>
-template<>
-inline MachineRegion* RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineRegion>() const {
+template <>
+template <>
+inline MachineRegion *
+RegionNodeBase<RegionTraits<MachineFunction>>::getNodeAs<MachineRegion>()
+    const {
   assert(isSubRegion() && "This is not a subregion RegionNode!");
-  auto Unconst = const_cast<RegionNodeBase<RegionTraits<MachineFunction>>*>(this);
-  return reinterpret_cast<MachineRegion*>(Unconst);
+  auto Unconst =
+      const_cast<RegionNodeBase<RegionTraits<MachineFunction>> *>(this);
+  return reinterpret_cast<MachineRegion *>(Unconst);
 }
 
-
 RegionNodeGraphTraits(MachineRegionNode, MachineBasicBlock, MachineRegion);
-RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock, MachineRegion);
+RegionNodeGraphTraits(const MachineRegionNode, MachineBasicBlock,
+                      MachineRegion);
 
 RegionGraphTraits(MachineRegion, MachineRegionNode);
 RegionGraphTraits(const MachineRegion, const MachineRegionNode);
 
-template <> struct GraphTraits<MachineRegionInfo*>
-  : public GraphTraits<FlatIt<MachineRegionNode*> > {
-  typedef df_iterator<NodeRef, df_iterator_default_set<NodeRef>, false,
-                      GraphTraits<FlatIt<NodeRef>>>
-      nodes_iterator;
+template <>
+struct GraphTraits<MachineRegionInfo *>
+    : public GraphTraits<FlatIt<MachineRegionNode *>> {
+  using nodes_iterator = df_iterator<NodeRef, df_iterator_default_set<NodeRef>,
+                                     false, GraphTraits<FlatIt<NodeRef>>>;
 
   static NodeRef getEntryNode(MachineRegionInfo *RI) {
-    return GraphTraits<FlatIt<MachineRegion*> >::getEntryNode(RI->getTopLevelRegion());
+    return GraphTraits<FlatIt<MachineRegion *>>::getEntryNode(
+        RI->getTopLevelRegion());
   }
-  static nodes_iterator nodes_begin(MachineRegionInfo* RI) {
+
+  static nodes_iterator nodes_begin(MachineRegionInfo *RI) {
     return nodes_iterator::begin(getEntryNode(RI));
   }
+
   static nodes_iterator nodes_end(MachineRegionInfo *RI) {
     return nodes_iterator::end(getEntryNode(RI));
   }
 };
 
-template <> struct GraphTraits<MachineRegionInfoPass*>
-  : public GraphTraits<MachineRegionInfo *> {
-  typedef df_iterator<NodeRef, df_iterator_default_set<NodeRef>, false,
-                      GraphTraits<FlatIt<NodeRef>>>
-      nodes_iterator;
+template <>
+struct GraphTraits<MachineRegionInfoPass *>
+    : public GraphTraits<MachineRegionInfo *> {
+  using nodes_iterator = df_iterator<NodeRef, df_iterator_default_set<NodeRef>,
+                                     false, GraphTraits<FlatIt<NodeRef>>>;
 
   static NodeRef getEntryNode(MachineRegionInfoPass *RI) {
-    return GraphTraits<MachineRegionInfo*>::getEntryNode(&RI->getRegionInfo());
+    return GraphTraits<MachineRegionInfo *>::getEntryNode(&RI->getRegionInfo());
   }
-  static nodes_iterator nodes_begin(MachineRegionInfoPass* RI) {
-    return GraphTraits<MachineRegionInfo*>::nodes_begin(&RI->getRegionInfo());
+
+  static nodes_iterator nodes_begin(MachineRegionInfoPass *RI) {
+    return GraphTraits<MachineRegionInfo *>::nodes_begin(&RI->getRegionInfo());
   }
+
   static nodes_iterator nodes_end(MachineRegionInfoPass *RI) {
-    return GraphTraits<MachineRegionInfo*>::nodes_end(&RI->getRegionInfo());
+    return GraphTraits<MachineRegionInfo *>::nodes_end(&RI->getRegionInfo());
   }
 };
 
 extern template class RegionBase<RegionTraits<MachineFunction>>;
 extern template class RegionNodeBase<RegionTraits<MachineFunction>>;
 extern template class RegionInfoBase<RegionTraits<MachineFunction>>;
-}
 
-#endif
+} // end namespace llvm
+
+#endif // LLVM_CODEGEN_MACHINEREGIONINFO_H