diff --git a/clang/include/clang/AST/DeclarationName.h b/clang/include/clang/AST/DeclarationName.h
index 3cb0a02ff49b..b7334bf3d3a2 100644
--- a/clang/include/clang/AST/DeclarationName.h
+++ b/clang/include/clang/AST/DeclarationName.h
@@ -27,6 +27,7 @@
 #include <cstdint>
 #include <cstring>
 #include <string>
+#include <type_traits>
 
 namespace clang {
 
@@ -194,6 +195,14 @@ class DeclarationName {
                 "The various classes that DeclarationName::Ptr can point to"
                 " must be at least aligned to 8 bytes!");
 
+  static_assert(std::is_same<
+                    std::underlying_type_t<StoredNameKind>,
+                    std::underlying_type_t<detail::DeclarationNameExtra::ExtraKind>
+                >::value,
+                "The various enums used to compute values for NameKind should "
+                "all have the same underlying type"
+                );
+
 public:
   /// The kind of the name stored in this DeclarationName.
   /// The first 7 enumeration values are stored inline and correspond
@@ -207,15 +216,18 @@ class DeclarationName {
     CXXDestructorName = StoredCXXDestructorName,
     CXXConversionFunctionName = StoredCXXConversionFunctionName,
     CXXOperatorName = StoredCXXOperatorName,
-    CXXDeductionGuideName = UncommonNameKindOffset +
-                            detail::DeclarationNameExtra::CXXDeductionGuideName,
+    CXXDeductionGuideName =
+        static_cast<std::underlying_type_t<StoredNameKind>>(UncommonNameKindOffset) +
+        static_cast<std::underlying_type_t<detail::DeclarationNameExtra::ExtraKind>>(detail::DeclarationNameExtra::CXXDeductionGuideName),
     CXXLiteralOperatorName =
-        UncommonNameKindOffset +
-        detail::DeclarationNameExtra::CXXLiteralOperatorName,
-    CXXUsingDirective = UncommonNameKindOffset +
-                        detail::DeclarationNameExtra::CXXUsingDirective,
-    ObjCMultiArgSelector = UncommonNameKindOffset +
-                           detail::DeclarationNameExtra::ObjCMultiArgSelector
+        static_cast<std::underlying_type_t<StoredNameKind>>(UncommonNameKindOffset) +
+        static_cast<std::underlying_type_t<detail::DeclarationNameExtra::ExtraKind>>(detail::DeclarationNameExtra::CXXLiteralOperatorName),
+    CXXUsingDirective =
+        static_cast<std::underlying_type_t<StoredNameKind>>(UncommonNameKindOffset) +
+        static_cast<std::underlying_type_t<detail::DeclarationNameExtra::ExtraKind>>(detail::DeclarationNameExtra::CXXUsingDirective),
+    ObjCMultiArgSelector =
+        static_cast<std::underlying_type_t<StoredNameKind>>(UncommonNameKindOffset) +
+        static_cast<std::underlying_type_t<detail::DeclarationNameExtra::ExtraKind>>(detail::DeclarationNameExtra::ObjCMultiArgSelector),
   };
 
 private:
diff --git a/llvm/include/llvm/ADT/StringRef.h b/llvm/include/llvm/ADT/StringRef.h
index 98c120fe2d2e..1f44aaff7b4f 100644
--- a/llvm/include/llvm/ADT/StringRef.h
+++ b/llvm/include/llvm/ADT/StringRef.h
@@ -76,6 +76,7 @@ namespace llvm {
       return ::memcmp(Lhs,Rhs,Length);
     }
 
+  protected:
     // Constexpr version of std::strlen.
     static constexpr size_t strLen(const char *Str) {
 #if __cplusplus > 201402L
@@ -91,6 +92,13 @@ namespace llvm {
 #endif
     }
 
+#if __cpp_char8_t
+    // Constexpr version of std::strlen for char8_t
+    static constexpr size_t strLen(const char8_t *Str) {
+      return std::char_traits<char8_t>::length(Str);
+    }
+#endif
+
   public:
     /// @name Constructors
     /// @{
@@ -106,10 +114,22 @@ namespace llvm {
     /*implicit*/ constexpr StringRef(const char *Str)
         : Data(Str), Length(Str ? strLen(Str) : 0) {}
 
+#if __cpp_char8_t
+    /// Construct a string ref from a cstring.
+    /*implicit*/ StringRef(const char8_t *Str)
+        : StringRef(reinterpret_cast<const char *>(Str)) {}
+#endif
+
     /// Construct a string ref from a pointer and length.
     /*implicit*/ constexpr StringRef(const char *data, size_t length)
         : Data(data), Length(length) {}
 
+#if __cpp_char8_t
+    /// Construct a string ref from a pointer and length.
+    /*implicit*/ StringRef(const char8_t *data, size_t length)
+        : StringRef(reinterpret_cast<const char *>(data), length) {}
+#endif
+
     /// Construct a string ref from an std::string.
     /*implicit*/ StringRef(const std::string &Str)
       : Data(Str.data()), Length(Str.length()) {}
@@ -874,19 +894,38 @@ namespace llvm {
     constexpr StringLiteral(const char *Str, size_t N) : StringRef(Str, N) {
     }
 
+#if __cpp_char8_t
+    StringLiteral(const char8_t *Str, size_t N) : StringRef(Str, N) {
+    }
+#endif
+
   public:
     template <size_t N>
     constexpr StringLiteral(const char (&Str)[N])
 #if defined(__clang__) && __has_attribute(enable_if)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wgcc-compat"
-        __attribute((enable_if(__builtin_strlen(Str) == N - 1,
+        __attribute((enable_if(strLen(Str) == N - 1,
                                "invalid string literal")))
 #pragma clang diagnostic pop
 #endif
         : StringRef(Str, N - 1) {
     }
 
+#if __cpp_char8_t
+    template <size_t N>
+    StringLiteral(const char8_t (&Str)[N])
+#if defined(__clang__) && __has_attribute(enable_if)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgcc-compat"
+        __attribute((enable_if(strLen(Str) == N - 1,
+                               "invalid string literal")))
+#pragma clang diagnostic pop
+#endif
+        : StringRef(Str, N - 1) {
+    }
+#endif
+
     // Explicit construction for strings like "foo\0bar".
     template <size_t N>
     static constexpr StringLiteral withInnerNUL(const char (&Str)[N]) {
diff --git a/llvm/include/llvm/Analysis/IteratedDominanceFrontier.h b/llvm/include/llvm/Analysis/IteratedDominanceFrontier.h
index 8166b52aa226..41ae1a572140 100644
--- a/llvm/include/llvm/Analysis/IteratedDominanceFrontier.h
+++ b/llvm/include/llvm/Analysis/IteratedDominanceFrontier.h
@@ -73,7 +73,7 @@ ChildrenGetterTy<BasicBlock, IsPostDom>::get(const NodeRef &N) {
     return {Children.begin(), Children.end()};
   }
 
-  return GD->template getChildren<IsPostDom>(N);
+  return GD->template getChildren<IsPostDom, DTIdentityView>(N);
 }
 
 } // end of namespace IDFCalculatorDetail
diff --git a/llvm/include/llvm/Analysis/LoopInfo.h b/llvm/include/llvm/Analysis/LoopInfo.h
index a5717bae12c3..b0130611bad7 100644
--- a/llvm/include/llvm/Analysis/LoopInfo.h
+++ b/llvm/include/llvm/Analysis/LoopInfo.h
@@ -62,7 +62,16 @@ class MDNode;
 class MemorySSAUpdater;
 class ScalarEvolution;
 class raw_ostream;
-template <class N, bool IsPostDom> class DominatorTreeBase;
+
+template<typename X>
+using DTIdentityView = X;
+
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+class DominatorTreeOnView;
+
+template <typename NodeT, bool IsPostDom>
+using DominatorTreeBase = DominatorTreeOnView<NodeT, IsPostDom, DTIdentityView>;
+
 template <class N, class M> class LoopInfoBase;
 template <class N, class M> class LoopBase;
 
diff --git a/llvm/include/llvm/CodeGen/LiveIntervalCalc.h b/llvm/include/llvm/CodeGen/LiveIntervalCalc.h
index 76005e835595..ee2bf65a3657 100644
--- a/llvm/include/llvm/CodeGen/LiveIntervalCalc.h
+++ b/llvm/include/llvm/CodeGen/LiveIntervalCalc.h
@@ -21,7 +21,14 @@
 
 namespace llvm {
 
-template <class NodeT> class DomTreeNodeBase;
+template<typename X>
+using DTIdentityView = X;
+
+template <typename NodeT, template<typename> class View>
+class DomTreeNodeOnView;
+
+template <typename NodeT>
+using DomTreeNodeBase = DomTreeNodeOnView<NodeT, DTIdentityView>;
 
 using MachineDomTreeNode = DomTreeNodeBase<MachineBasicBlock>;
 
diff --git a/llvm/include/llvm/CodeGen/LiveRangeCalc.h b/llvm/include/llvm/CodeGen/LiveRangeCalc.h
index bbb6f2ddd233..f0cf1fad723b 100644
--- a/llvm/include/llvm/CodeGen/LiveRangeCalc.h
+++ b/llvm/include/llvm/CodeGen/LiveRangeCalc.h
@@ -36,13 +36,21 @@
 
 namespace llvm {
 
-template <class NodeT> class DomTreeNodeBase;
+template<typename X>
+using DTIdentityView = X;
+
+template <typename NodeT, template<typename> class View>
+class DomTreeNodeOnView;
+
+template <typename NodeT>
+using DomTreeNodeBase = DomTreeNodeOnView<NodeT, DTIdentityView>;
+
+using MachineDomTreeNode = DomTreeNodeBase<MachineBasicBlock>;
+
 class MachineDominatorTree;
 class MachineFunction;
 class MachineRegisterInfo;
 
-using MachineDomTreeNode = DomTreeNodeBase<MachineBasicBlock>;
-
 class LiveRangeCalc {
   const MachineFunction *MF = nullptr;
   const MachineRegisterInfo *MRI = nullptr;
diff --git a/llvm/include/llvm/CodeGen/MachineDominators.h b/llvm/include/llvm/CodeGen/MachineDominators.h
index 46bf73cdd7b6..a96dea5985c0 100644
--- a/llvm/include/llvm/CodeGen/MachineDominators.h
+++ b/llvm/include/llvm/CodeGen/MachineDominators.h
@@ -32,9 +32,9 @@ inline void DominatorTreeBase<MachineBasicBlock, false>::addRoot(
   this->Roots.push_back(MBB);
 }
 
-extern template class DomTreeNodeBase<MachineBasicBlock>;
-extern template class DominatorTreeBase<MachineBasicBlock, false>; // DomTree
-extern template class DominatorTreeBase<MachineBasicBlock, true>; // PostDomTree
+extern template class DomTreeNodeOnView<MachineBasicBlock, DTIdentityView>;
+extern template class DominatorTreeOnView<MachineBasicBlock, false, DTIdentityView>; // DomTree
+extern template class DominatorTreeOnView<MachineBasicBlock, true, DTIdentityView>; // PostDomTree
 
 using MachineDomTreeNode = DomTreeNodeBase<MachineBasicBlock>;
 
diff --git a/llvm/include/llvm/IR/Dominators.h b/llvm/include/llvm/IR/Dominators.h
index 08dbccaf2c01..de5a5306669d 100644
--- a/llvm/include/llvm/IR/Dominators.h
+++ b/llvm/include/llvm/IR/Dominators.h
@@ -32,50 +32,57 @@ class Instruction;
 class Module;
 class raw_ostream;
 
-extern template class DomTreeNodeBase<BasicBlock>;
-extern template class DominatorTreeBase<BasicBlock, false>; // DomTree
-extern template class DominatorTreeBase<BasicBlock, true>; // PostDomTree
+extern template class DomTreeNodeOnView<BasicBlock, DTIdentityView>;
+extern template class DominatorTreeOnView<BasicBlock, false, DTIdentityView>; // DomTree
+extern template class DominatorTreeOnView<BasicBlock, true, DTIdentityView>; // PostDomTree
 
 extern template class cfg::Update<BasicBlock *>;
 
 namespace DomTreeBuilder {
-using BBDomTree = DomTreeBase<BasicBlock>;
-using BBPostDomTree = PostDomTreeBase<BasicBlock>;
+template<template<typename> class View>
+using BBDomTreeOnView = DomTreeOnView<BasicBlock, View>;
+
+using BBDomTree = DomTreeOnView<BasicBlock, DTIdentityView>;
+
+template<template<typename> class View>
+using BBPostDomTreeOnView = PostDomTreeOnView<BasicBlock, View>;
+
+using BBPostDomTree = PostDomTreeOnView<BasicBlock, DTIdentityView>;
 
 using BBUpdates = ArrayRef<llvm::cfg::Update<BasicBlock *>>;
 
-using BBDomTreeGraphDiff = GraphDiff<BasicBlock *, false>;
-using BBPostDomTreeGraphDiff = GraphDiff<BasicBlock *, true>;
-
-extern template void Calculate<BBDomTree>(BBDomTree &DT);
-extern template void CalculateWithUpdates<BBDomTree>(BBDomTree &DT,
-                                                     BBUpdates U);
-
-extern template void Calculate<BBPostDomTree>(BBPostDomTree &DT);
-
-extern template void InsertEdge<BBDomTree>(BBDomTree &DT, BasicBlock *From,
-                                           BasicBlock *To);
-extern template void InsertEdge<BBPostDomTree>(BBPostDomTree &DT,
-                                               BasicBlock *From,
-                                               BasicBlock *To);
-
-extern template void DeleteEdge<BBDomTree>(BBDomTree &DT, BasicBlock *From,
-                                           BasicBlock *To);
-extern template void DeleteEdge<BBPostDomTree>(BBPostDomTree &DT,
-                                               BasicBlock *From,
-                                               BasicBlock *To);
-
-extern template void ApplyUpdates<BBDomTree>(BBDomTree &DT,
-                                             BBDomTreeGraphDiff &,
-                                             BBDomTreeGraphDiff *);
-extern template void ApplyUpdates<BBPostDomTree>(BBPostDomTree &DT,
-                                                 BBPostDomTreeGraphDiff &,
-                                                 BBPostDomTreeGraphDiff *);
-
-extern template bool Verify<BBDomTree>(const BBDomTree &DT,
-                                       BBDomTree::VerificationLevel VL);
-extern template bool Verify<BBPostDomTree>(const BBPostDomTree &DT,
-                                           BBPostDomTree::VerificationLevel VL);
+using BBDomTreeGraphDiff = GraphDiff<BBDomTree::NodePtr, false>;
+using BBPostDomTreeGraphDiff = GraphDiff<BBPostDomTree::NodePtr, true>;
+
+extern template void Calculate<BasicBlock, false, DTIdentityView>(BBDomTree &DT);
+extern template void
+CalculateWithUpdates<BasicBlock, false, DTIdentityView>(BBDomTree &DT, BBUpdates U);
+
+extern template void Calculate<BasicBlock, true, DTIdentityView>(BBPostDomTree &DT);
+
+extern template void
+InsertEdge<BasicBlock, false, DTIdentityView>(BBDomTree &DT, BasicBlock *From, BasicBlock *To);
+extern template void
+InsertEdge<BasicBlock, true, DTIdentityView>(BBPostDomTree &DT, BasicBlock *From, BasicBlock *To);
+
+extern template void
+DeleteEdge<BasicBlock, false, DTIdentityView>(BBDomTree &DT, BasicBlock *From, BasicBlock *To);
+extern template void
+DeleteEdge<BasicBlock, true, DTIdentityView>(BBPostDomTree &DT, BasicBlock *From, BasicBlock *To);
+
+extern template void
+ApplyUpdates<BasicBlock, false, DTIdentityView>(BBDomTree &DT,
+                                                BBDomTreeGraphDiff &,
+                                                BBDomTreeGraphDiff *);
+extern template void
+ApplyUpdates<BasicBlock, true, DTIdentityView>(BBPostDomTree &DT,
+                                               BBPostDomTreeGraphDiff &,
+                                               BBPostDomTreeGraphDiff *);
+
+extern template bool
+Verify<BasicBlock, false, DTIdentityView>(const BBDomTree &DT, BBDomTree::VerificationLevel VL);
+extern template bool
+Verify<BasicBlock, true, DTIdentityView>(const BBPostDomTree &DT, BBPostDomTree::VerificationLevel VL);
 }  // namespace DomTreeBuilder
 
 using DomTreeNode = DomTreeNodeBase<BasicBlock>;
diff --git a/llvm/include/llvm/Support/CFGDiff.h b/llvm/include/llvm/Support/CFGDiff.h
index c90b9aca78b5..b0a50690d228 100644
--- a/llvm/include/llvm/Support/CFGDiff.h
+++ b/llvm/include/llvm/Support/CFGDiff.h
@@ -132,11 +132,12 @@ template <typename NodePtr, bool InverseGraph = false> class GraphDiff {
   }
 
   using VectRet = SmallVector<NodePtr, 8>;
-  template <bool InverseEdge> VectRet getChildren(NodePtr N) const {
+  template <bool InverseEdge, template <typename> class View> VectRet getChildren(NodePtr N) const {
     using DirectedNodeT =
-        std::conditional_t<InverseEdge, Inverse<NodePtr>, NodePtr>;
-    auto R = children<DirectedNodeT>(N);
-    VectRet Res = VectRet(detail::reverse_if<!InverseEdge>(R));
+        std::conditional_t<InverseEdge, Inverse<View<NodePtr>>, View<NodePtr>>;
+    VectRet Res = VectRet(children<DirectedNodeT>(N));
+    if (not InverseEdge)
+      std::reverse(Res.begin(), Res.end());
 
     // Remove nullptr children for clang.
     llvm::erase_value(Res, nullptr);
diff --git a/llvm/include/llvm/Support/GenericDomTree.h b/llvm/include/llvm/Support/GenericDomTree.h
index 18e08dbcd175..0bb6c5749a56 100644
--- a/llvm/include/llvm/Support/GenericDomTree.h
+++ b/llvm/include/llvm/Support/GenericDomTree.h
@@ -41,44 +41,51 @@
 
 namespace llvm {
 
+template<typename X>
+using DTIdentityView = X;
+
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+class DominatorTreeOnView;
+
 template <typename NodeT, bool IsPostDom>
-class DominatorTreeBase;
+using DominatorTreeBase = DominatorTreeOnView<NodeT, IsPostDom, DTIdentityView>;
 
 namespace DomTreeBuilder {
-template <typename DomTreeT>
-struct SemiNCAInfo;
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+struct SemiNCAInfoOnView;
 }  // namespace DomTreeBuilder
 
 /// Base class for the actual dominator tree node.
-template <class NodeT> class DomTreeNodeBase {
+template <class NodeT, template<typename> class View>
+class DomTreeNodeOnView {
   friend class PostDominatorTree;
-  friend class DominatorTreeBase<NodeT, false>;
-  friend class DominatorTreeBase<NodeT, true>;
-  friend struct DomTreeBuilder::SemiNCAInfo<DominatorTreeBase<NodeT, false>>;
-  friend struct DomTreeBuilder::SemiNCAInfo<DominatorTreeBase<NodeT, true>>;
+  friend class DominatorTreeOnView<NodeT, false, View>;
+  friend class DominatorTreeOnView<NodeT, true, View>;
+  friend struct DomTreeBuilder::SemiNCAInfoOnView<NodeT, false, View>;
+  friend struct DomTreeBuilder::SemiNCAInfoOnView<NodeT, true, View>;
 
   NodeT *TheBB;
-  DomTreeNodeBase *IDom;
+  DomTreeNodeOnView *IDom;
   unsigned Level;
-  SmallVector<DomTreeNodeBase *, 4> Children;
+  SmallVector<DomTreeNodeOnView *, 4> Children;
   mutable unsigned DFSNumIn = ~0;
   mutable unsigned DFSNumOut = ~0;
 
  public:
-  DomTreeNodeBase(NodeT *BB, DomTreeNodeBase *iDom)
+  DomTreeNodeOnView(NodeT *BB, DomTreeNodeOnView *iDom)
       : TheBB(BB), IDom(iDom), Level(IDom ? IDom->Level + 1 : 0) {}
 
-  using iterator = typename SmallVector<DomTreeNodeBase *, 4>::iterator;
+  using iterator = typename SmallVector<DomTreeNodeOnView *, 4>::iterator;
   using const_iterator =
-      typename SmallVector<DomTreeNodeBase *, 4>::const_iterator;
+      typename SmallVector<DomTreeNodeOnView *, 4>::const_iterator;
 
   iterator begin() { return Children.begin(); }
   iterator end() { return Children.end(); }
   const_iterator begin() const { return Children.begin(); }
   const_iterator end() const { return Children.end(); }
 
-  DomTreeNodeBase *const &back() const { return Children.back(); }
-  DomTreeNodeBase *&back() { return Children.back(); }
+  DomTreeNodeOnView *const &back() const { return Children.back(); }
+  DomTreeNodeOnView *&back() { return Children.back(); }
 
   iterator_range<iterator> children() { return make_range(begin(), end()); }
   iterator_range<const_iterator> children() const {
@@ -86,11 +93,11 @@ template <class NodeT> class DomTreeNodeBase {
   }
 
   NodeT *getBlock() const { return TheBB; }
-  DomTreeNodeBase *getIDom() const { return IDom; }
+  DomTreeNodeOnView *getIDom() const { return IDom; }
   unsigned getLevel() const { return Level; }
 
-  std::unique_ptr<DomTreeNodeBase> addChild(
-      std::unique_ptr<DomTreeNodeBase> C) {
+  std::unique_ptr<DomTreeNodeOnView> addChild(
+      std::unique_ptr<DomTreeNodeOnView> C) {
     Children.push_back(C.get());
     return C;
   }
@@ -100,19 +107,19 @@ template <class NodeT> class DomTreeNodeBase {
 
   void clearAllChildren() { Children.clear(); }
 
-  bool compare(const DomTreeNodeBase *Other) const {
+  bool compare(const DomTreeNodeOnView *Other) const {
     if (getNumChildren() != Other->getNumChildren())
       return true;
 
     if (Level != Other->Level) return true;
 
     SmallPtrSet<const NodeT *, 4> OtherChildren;
-    for (const DomTreeNodeBase *I : *Other) {
+    for (const DomTreeNodeOnView *I : *Other) {
       const NodeT *Nd = I->getBlock();
       OtherChildren.insert(Nd);
     }
 
-    for (const DomTreeNodeBase *I : *this) {
+    for (const DomTreeNodeOnView *I : *this) {
       const NodeT *N = I->getBlock();
       if (OtherChildren.count(N) == 0)
         return true;
@@ -120,7 +127,7 @@ template <class NodeT> class DomTreeNodeBase {
     return false;
   }
 
-  void setIDom(DomTreeNodeBase *NewIDom) {
+  void setIDom(DomTreeNodeOnView *NewIDom) {
     assert(IDom && "No immediate dominator?");
     if (IDom == NewIDom) return;
 
@@ -146,7 +153,7 @@ template <class NodeT> class DomTreeNodeBase {
 private:
   // Return true if this node is dominated by other. Use this only if DFS info
   // is valid.
-  bool DominatedBy(const DomTreeNodeBase *other) const {
+  bool DominatedBy(const DomTreeNodeOnView *other) const {
     return this->DFSNumIn >= other->DFSNumIn &&
            this->DFSNumOut <= other->DFSNumOut;
   }
@@ -155,13 +162,13 @@ template <class NodeT> class DomTreeNodeBase {
     assert(IDom);
     if (Level == IDom->Level + 1) return;
 
-    SmallVector<DomTreeNodeBase *, 64> WorkStack = {this};
+    SmallVector<DomTreeNodeOnView *, 64> WorkStack = {this};
 
     while (!WorkStack.empty()) {
-      DomTreeNodeBase *Current = WorkStack.pop_back_val();
+      DomTreeNodeOnView *Current = WorkStack.pop_back_val();
       Current->Level = Current->IDom->Level + 1;
 
-      for (DomTreeNodeBase *C : *Current) {
+      for (DomTreeNodeOnView *C : *Current) {
         assert(C->IDom);
         if (C->Level != C->IDom->Level + 1) WorkStack.push_back(C);
       }
@@ -170,7 +177,10 @@ template <class NodeT> class DomTreeNodeBase {
 };
 
 template <class NodeT>
-raw_ostream &operator<<(raw_ostream &O, const DomTreeNodeBase<NodeT> *Node) {
+using DomTreeNodeBase = DomTreeNodeOnView<NodeT, DTIdentityView>;
+
+template <class NodeT, template<typename> class View>
+raw_ostream &operator<<(raw_ostream &O, const DomTreeNodeOnView<NodeT, View> *Node) {
   if (Node->getBlock())
     Node->getBlock()->printAsOperand(O, false);
   else
@@ -182,11 +192,11 @@ raw_ostream &operator<<(raw_ostream &O, const DomTreeNodeBase<NodeT> *Node) {
   return O;
 }
 
-template <class NodeT>
-void PrintDomTree(const DomTreeNodeBase<NodeT> *N, raw_ostream &O,
+template <class NodeT, template<typename> class View>
+void PrintDomTree(const DomTreeNodeOnView<NodeT, View> *N, raw_ostream &O,
                   unsigned Lev) {
   O.indent(2 * Lev) << "[" << Lev << "] " << N;
-  for (typename DomTreeNodeBase<NodeT>::const_iterator I = N->begin(),
+  for (typename DomTreeNodeOnView<NodeT, View>::const_iterator I = N->begin(),
                                                        E = N->end();
        I != E; ++I)
     PrintDomTree<NodeT>(*I, O, Lev + 1);
@@ -194,41 +204,42 @@ void PrintDomTree(const DomTreeNodeBase<NodeT> *N, raw_ostream &O,
 
 namespace DomTreeBuilder {
 // The routines below are provided in a separate header but referenced here.
-template <typename DomTreeT>
-void Calculate(DomTreeT &DT);
-
-template <typename DomTreeT>
-void CalculateWithUpdates(DomTreeT &DT,
-                          ArrayRef<typename DomTreeT::UpdateType> Updates);
-
-template <typename DomTreeT>
-void InsertEdge(DomTreeT &DT, typename DomTreeT::NodePtr From,
-                typename DomTreeT::NodePtr To);
-
-template <typename DomTreeT>
-void DeleteEdge(DomTreeT &DT, typename DomTreeT::NodePtr From,
-                typename DomTreeT::NodePtr To);
-
-template <typename DomTreeT>
-void ApplyUpdates(DomTreeT &DT,
-                  GraphDiff<typename DomTreeT::NodePtr,
-                            DomTreeT::IsPostDominator> &PreViewCFG,
-                  GraphDiff<typename DomTreeT::NodePtr,
-                            DomTreeT::IsPostDominator> *PostViewCFG);
-
-template <typename DomTreeT>
-bool Verify(const DomTreeT &DT, typename DomTreeT::VerificationLevel VL);
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void Calculate(DominatorTreeOnView<NodeT, IsPostDom, View> &DT);
+
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void CalculateWithUpdates(DominatorTreeOnView<NodeT, IsPostDom, View> &DT,
+                          ArrayRef<typename DominatorTreeOnView<NodeT, IsPostDom, View>::UpdateType> Updates);
+
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void InsertEdge(DominatorTreeOnView<NodeT, IsPostDom, View> &DT,
+                typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr From,
+                typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr To);
+
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void DeleteEdge(DominatorTreeOnView<NodeT, IsPostDom, View> &DT,
+                typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr From,
+                typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr To);
+
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void ApplyUpdates(DominatorTreeOnView<NodeT, IsPostDom, View> &DT,
+                  GraphDiff<typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr, IsPostDom> &PreViewCFG,
+                  GraphDiff<typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr, IsPostDom> *PostViewCFG);
+
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+bool Verify(const DominatorTreeOnView<NodeT, IsPostDom, View> &DT,
+            typename DominatorTreeOnView<NodeT, IsPostDom, View>::VerificationLevel VL);
 }  // namespace DomTreeBuilder
 
 /// Core dominator tree base class.
 ///
 /// This class is a generic template over graph nodes. It is instantiated for
 /// various graphs in the LLVM IR or in the code generator.
-template <typename NodeT, bool IsPostDom>
-class DominatorTreeBase {
+template <typename NodeT, bool IsPostDom, template<typename X> class View>
+class DominatorTreeOnView {
  public:
   static_assert(std::is_pointer<typename GraphTraits<NodeT *>::NodeRef>::value,
-                "Currently DominatorTreeBase supports only pointer nodes");
+                "Currently DominatorTreeOnView supports only pointer nodes");
   using NodeType = NodeT;
   using NodePtr = NodeT *;
   using ParentPtr = decltype(std::declval<NodeT *>()->getParent());
@@ -249,20 +260,21 @@ class DominatorTreeBase {
   SmallVector<NodeT *, IsPostDom ? 4 : 1> Roots;
 
   using DomTreeNodeMapType =
-     DenseMap<NodeT *, std::unique_ptr<DomTreeNodeBase<NodeT>>>;
+     DenseMap<NodeT *, std::unique_ptr<DomTreeNodeOnView<NodeT, View>>>;
   DomTreeNodeMapType DomTreeNodes;
-  DomTreeNodeBase<NodeT> *RootNode = nullptr;
+  DomTreeNodeOnView<NodeT, View> *RootNode = nullptr;
   ParentPtr Parent = nullptr;
 
   mutable bool DFSInfoValid = false;
   mutable unsigned int SlowQueries = 0;
 
-  friend struct DomTreeBuilder::SemiNCAInfo<DominatorTreeBase>;
+  friend struct DomTreeBuilder::SemiNCAInfoOnView<NodeT, true, View>;
+  friend struct DomTreeBuilder::SemiNCAInfoOnView<NodeT, false, View>;
 
  public:
-  DominatorTreeBase() {}
+  DominatorTreeOnView() {}
 
-  DominatorTreeBase(DominatorTreeBase &&Arg)
+  DominatorTreeOnView(DominatorTreeOnView &&Arg)
       : Roots(std::move(Arg.Roots)),
         DomTreeNodes(std::move(Arg.DomTreeNodes)),
         RootNode(Arg.RootNode),
@@ -272,7 +284,7 @@ class DominatorTreeBase {
     Arg.wipe();
   }
 
-  DominatorTreeBase &operator=(DominatorTreeBase &&RHS) {
+  DominatorTreeOnView &operator=(DominatorTreeOnView &&RHS) {
     Roots = std::move(RHS.Roots);
     DomTreeNodes = std::move(RHS.DomTreeNodes);
     RootNode = RHS.RootNode;
@@ -283,8 +295,8 @@ class DominatorTreeBase {
     return *this;
   }
 
-  DominatorTreeBase(const DominatorTreeBase &) = delete;
-  DominatorTreeBase &operator=(const DominatorTreeBase &) = delete;
+  DominatorTreeOnView(const DominatorTreeOnView &) = delete;
+  DominatorTreeOnView &operator=(const DominatorTreeOnView &) = delete;
 
   /// Iteration over roots.
   ///
@@ -314,7 +326,7 @@ class DominatorTreeBase {
 
   /// compare - Return false if the other dominator tree base matches this
   /// dominator tree base. Otherwise return true.
-  bool compare(const DominatorTreeBase &Other) const {
+  bool compare(const DominatorTreeOnView &Other) const {
     if (Parent != Other.Parent) return true;
 
     if (Roots.size() != Other.Roots.size())
@@ -334,8 +346,8 @@ class DominatorTreeBase {
       if (OI == OtherDomTreeNodes.end())
         return true;
 
-      DomTreeNodeBase<NodeT> &MyNd = *DomTreeNode.second;
-      DomTreeNodeBase<NodeT> &OtherNd = *OI->second;
+      DomTreeNodeOnView<NodeT, View> &MyNd = *DomTreeNode.second;
+      DomTreeNodeOnView<NodeT, View> &OtherNd = *OI->second;
 
       if (MyNd.compare(&OtherNd))
         return true;
@@ -348,7 +360,7 @@ class DominatorTreeBase {
   /// block.  This is the same as using operator[] on this class.  The result
   /// may (but is not required to) be null for a forward (backwards)
   /// statically unreachable block.
-  DomTreeNodeBase<NodeT> *getNode(const NodeT *BB) const {
+  DomTreeNodeOnView<NodeT, View> *getNode(const NodeT *BB) const {
     auto I = DomTreeNodes.find(BB);
     if (I != DomTreeNodes.end())
       return I->second.get();
@@ -356,7 +368,7 @@ class DominatorTreeBase {
   }
 
   /// See getNode.
-  DomTreeNodeBase<NodeT> *operator[](const NodeT *BB) const {
+  DomTreeNodeOnView<NodeT, View> *operator[](const NodeT *BB) const {
     return getNode(BB);
   }
 
@@ -367,20 +379,20 @@ class DominatorTreeBase {
   /// post-dominance information must be capable of dealing with this
   /// possibility.
   ///
-  DomTreeNodeBase<NodeT> *getRootNode() { return RootNode; }
-  const DomTreeNodeBase<NodeT> *getRootNode() const { return RootNode; }
+  DomTreeNodeOnView<NodeT, View> *getRootNode() { return RootNode; }
+  const DomTreeNodeOnView<NodeT, View> *getRootNode() const { return RootNode; }
 
   /// Get all nodes dominated by R, including R itself.
   void getDescendants(NodeT *R, SmallVectorImpl<NodeT *> &Result) const {
     Result.clear();
-    const DomTreeNodeBase<NodeT> *RN = getNode(R);
+    const DomTreeNodeOnView<NodeT, View> *RN = getNode(R);
     if (!RN)
       return; // If R is unreachable, it will not be present in the DOM tree.
-    SmallVector<const DomTreeNodeBase<NodeT> *, 8> WL;
+    SmallVector<const DomTreeNodeOnView<NodeT, View> *, 8> WL;
     WL.push_back(RN);
 
     while (!WL.empty()) {
-      const DomTreeNodeBase<NodeT> *N = WL.pop_back_val();
+      const DomTreeNodeOnView<NodeT, View> *N = WL.pop_back_val();
       Result.push_back(N->getBlock());
       WL.append(N->begin(), N->end());
     }
@@ -389,8 +401,8 @@ class DominatorTreeBase {
   /// properlyDominates - Returns true iff A dominates B and A != B.
   /// Note that this is not a constant time operation!
   ///
-  bool properlyDominates(const DomTreeNodeBase<NodeT> *A,
-                         const DomTreeNodeBase<NodeT> *B) const {
+  bool properlyDominates(const DomTreeNodeOnView<NodeT, View> *A,
+                         const DomTreeNodeOnView<NodeT, View> *B) const {
     if (!A || !B)
       return false;
     if (A == B)
@@ -408,13 +420,13 @@ class DominatorTreeBase {
     return isReachableFromEntry(getNode(const_cast<NodeT *>(A)));
   }
 
-  bool isReachableFromEntry(const DomTreeNodeBase<NodeT> *A) const { return A; }
+  bool isReachableFromEntry(const DomTreeNodeOnView<NodeT, View> *A) const { return A; }
 
   /// dominates - Returns true iff A dominates B.  Note that this is not a
   /// constant time operation!
   ///
-  bool dominates(const DomTreeNodeBase<NodeT> *A,
-                 const DomTreeNodeBase<NodeT> *B) const {
+  bool dominates(const DomTreeNodeOnView<NodeT, View> *A,
+                 const DomTreeNodeOnView<NodeT, View> *B) const {
     // A node trivially dominates itself.
     if (B == A)
       return true;
@@ -478,8 +490,8 @@ class DominatorTreeBase {
         return &Entry;
     }
 
-    DomTreeNodeBase<NodeT> *NodeA = getNode(A);
-    DomTreeNodeBase<NodeT> *NodeB = getNode(B);
+    DomTreeNodeOnView<NodeT, View> *NodeA = getNode(A);
+    DomTreeNodeOnView<NodeT, View> *NodeB = getNode(B);
     assert(NodeA && "A must be in the tree");
     assert(NodeB && "B must be in the tree");
 
@@ -502,7 +514,7 @@ class DominatorTreeBase {
                                       const_cast<NodeT *>(B));
   }
 
-  bool isVirtualRoot(const DomTreeNodeBase<NodeT> *A) const {
+  bool isVirtualRoot(const DomTreeNodeOnView<NodeT, View> *A) const {
     return isPostDominator() && !A->getBlock();
   }
 
@@ -544,7 +556,7 @@ class DominatorTreeBase {
   void applyUpdates(ArrayRef<UpdateType> Updates) {
     GraphDiff<NodePtr, IsPostDominator> PreViewCFG(
         Updates, /*ReverseApplyUpdates=*/true);
-    DomTreeBuilder::ApplyUpdates(*this, PreViewCFG, nullptr);
+    DomTreeBuilder::ApplyUpdates<NodeT, IsPostDom, View>(*this, PreViewCFG, nullptr);
   }
 
   /// \param Updates An unordered sequence of updates to perform. The current
@@ -556,7 +568,7 @@ class DominatorTreeBase {
                     ArrayRef<UpdateType> PostViewUpdates) {
     if (Updates.empty()) {
       GraphDiff<NodePtr, IsPostDom> PostViewCFG(PostViewUpdates);
-      DomTreeBuilder::ApplyUpdates(*this, PostViewCFG, &PostViewCFG);
+      DomTreeBuilder::ApplyUpdates<NodeT, IsPostDom, View>(*this, PostViewCFG, &PostViewCFG);
     } else {
       // PreViewCFG needs to merge Updates and PostViewCFG. The updates in
       // Updates need to be reversed, and match the direction in PostViewCFG.
@@ -569,7 +581,7 @@ class DominatorTreeBase {
       GraphDiff<NodePtr, IsPostDom> PreViewCFG(AllUpdates,
                                                /*ReverseApplyUpdates=*/true);
       GraphDiff<NodePtr, IsPostDom> PostViewCFG(PostViewUpdates);
-      DomTreeBuilder::ApplyUpdates(*this, PreViewCFG, &PostViewCFG);
+      DomTreeBuilder::ApplyUpdates<NodeT, IsPostDom, View>(*this, PreViewCFG, &PostViewCFG);
     }
   }
 
@@ -617,9 +629,9 @@ class DominatorTreeBase {
   /// \param DomBB CFG node that is dominator for BB.
   /// \returns New dominator tree node that represents new CFG node.
   ///
-  DomTreeNodeBase<NodeT> *addNewBlock(NodeT *BB, NodeT *DomBB) {
+  DomTreeNodeOnView<NodeT, View> *addNewBlock(NodeT *BB, NodeT *DomBB) {
     assert(getNode(BB) == nullptr && "Block already in dominator tree!");
-    DomTreeNodeBase<NodeT> *IDomNode = getNode(DomBB);
+    DomTreeNodeOnView<NodeT, View> *IDomNode = getNode(DomBB);
     assert(IDomNode && "Not immediate dominator specified for block!");
     DFSInfoValid = false;
     return createChild(BB, IDomNode);
@@ -630,12 +642,12 @@ class DominatorTreeBase {
   /// \param BB New node in CFG.
   /// \returns New dominator tree node that represents new CFG node.
   ///
-  DomTreeNodeBase<NodeT> *setNewRoot(NodeT *BB) {
+  DomTreeNodeOnView<NodeT, View> *setNewRoot(NodeT *BB) {
     assert(getNode(BB) == nullptr && "Block already in dominator tree!");
     assert(!this->isPostDominator() &&
            "Cannot change root of post-dominator tree");
     DFSInfoValid = false;
-    DomTreeNodeBase<NodeT> *NewNode = createNode(BB);
+    DomTreeNodeOnView<NodeT, View> *NewNode = createNode(BB);
     if (Roots.empty()) {
       addRoot(BB);
     } else {
@@ -653,8 +665,8 @@ class DominatorTreeBase {
   /// changeImmediateDominator - This method is used to update the dominator
   /// tree information when a node's immediate dominator changes.
   ///
-  void changeImmediateDominator(DomTreeNodeBase<NodeT> *N,
-                                DomTreeNodeBase<NodeT> *NewIDom) {
+  void changeImmediateDominator(DomTreeNodeOnView<NodeT, View> *N,
+                                DomTreeNodeOnView<NodeT, View> *NewIDom) {
     assert(N && NewIDom && "Cannot change null node pointers!");
     DFSInfoValid = false;
     N->setIDom(NewIDom);
@@ -668,14 +680,14 @@ class DominatorTreeBase {
   /// dominate any other blocks. Removes node from its immediate dominator's
   /// children list. Deletes dominator node associated with basic block BB.
   void eraseNode(NodeT *BB) {
-    DomTreeNodeBase<NodeT> *Node = getNode(BB);
+    DomTreeNodeOnView<NodeT, View> *Node = getNode(BB);
     assert(Node && "Removing node that isn't in dominator tree.");
     assert(Node->isLeaf() && "Node is not a leaf node.");
 
     DFSInfoValid = false;
 
     // Remove node from immediate dominator's children list.
-    DomTreeNodeBase<NodeT> *IDom = Node->getIDom();
+    DomTreeNodeOnView<NodeT, View> *IDom = Node->getIDom();
     if (IDom) {
       const auto I = find(IDom->Children, Node);
       assert(I != IDom->Children.end() &&
@@ -700,9 +712,9 @@ class DominatorTreeBase {
   /// tree to reflect this change.
   void splitBlock(NodeT *NewBB) {
     if (IsPostDominator)
-      Split<Inverse<NodeT *>>(NewBB);
+      Split<Inverse<View<NodeT *>>>(NewBB);
     else
-      Split<NodeT *>(NewBB);
+      Split<View<NodeT *>>(NewBB);
   }
 
   /// print - Convert to human readable form
@@ -736,11 +748,11 @@ class DominatorTreeBase {
       return;
     }
 
-    SmallVector<std::pair<const DomTreeNodeBase<NodeT> *,
-                          typename DomTreeNodeBase<NodeT>::const_iterator>,
+    SmallVector<std::pair<const DomTreeNodeOnView<NodeT, View> *,
+                          typename DomTreeNodeOnView<NodeT, View>::const_iterator>,
                 32> WorkStack;
 
-    const DomTreeNodeBase<NodeT> *ThisRoot = getRootNode();
+    const DomTreeNodeOnView<NodeT, View> *ThisRoot = getRootNode();
     assert((!Parent || ThisRoot) && "Empty constructed DomTree");
     if (!ThisRoot)
       return;
@@ -753,7 +765,7 @@ class DominatorTreeBase {
     ThisRoot->DFSNumIn = DFSNum++;
 
     while (!WorkStack.empty()) {
-      const DomTreeNodeBase<NodeT> *Node = WorkStack.back().first;
+      const DomTreeNodeOnView<NodeT, View> *Node = WorkStack.back().first;
       const auto ChildIt = WorkStack.back().second;
 
       // If we visited all of the children of this node, "recurse" back up the
@@ -763,7 +775,7 @@ class DominatorTreeBase {
         WorkStack.pop_back();
       } else {
         // Otherwise, recursively visit this child.
-        const DomTreeNodeBase<NodeT> *Child = *ChildIt;
+        const DomTreeNodeOnView<NodeT, View> *Child = *ChildIt;
         ++WorkStack.back().second;
 
         WorkStack.push_back({Child, Child->begin()});
@@ -816,15 +828,16 @@ class DominatorTreeBase {
 protected:
   void addRoot(NodeT *BB) { this->Roots.push_back(BB); }
 
-  DomTreeNodeBase<NodeT> *createChild(NodeT *BB, DomTreeNodeBase<NodeT> *IDom) {
+  DomTreeNodeOnView<NodeT, View> *
+  createChild(NodeT *BB, DomTreeNodeOnView<NodeT, View> *IDom) {
     return (DomTreeNodes[BB] = IDom->addChild(
-                std::make_unique<DomTreeNodeBase<NodeT>>(BB, IDom)))
+                std::make_unique<DomTreeNodeOnView<NodeT, View>>(BB, IDom)))
         .get();
   }
 
-  DomTreeNodeBase<NodeT> *createNode(NodeT *BB) {
+  DomTreeNodeOnView<NodeT, View> *createNode(NodeT *BB) {
     return (DomTreeNodes[BB] =
-                std::make_unique<DomTreeNodeBase<NodeT>>(BB, nullptr))
+                std::make_unique<DomTreeNodeOnView<NodeT, View>>(BB, nullptr))
         .get();
   }
 
@@ -873,25 +886,25 @@ class DominatorTreeBase {
     }
 
     // Create the new dominator tree node... and set the idom of NewBB.
-    DomTreeNodeBase<NodeT> *NewBBNode = addNewBlock(NewBB, NewBBIDom);
+    DomTreeNodeOnView<NodeT, View> *NewBBNode = addNewBlock(NewBB, NewBBIDom);
 
     // If NewBB strictly dominates other blocks, then it is now the immediate
     // dominator of NewBBSucc.  Update the dominator tree as appropriate.
     if (NewBBDominatesNewBBSucc) {
-      DomTreeNodeBase<NodeT> *NewBBSuccNode = getNode(NewBBSucc);
+      DomTreeNodeOnView<NodeT, View> *NewBBSuccNode = getNode(NewBBSucc);
       changeImmediateDominator(NewBBSuccNode, NewBBNode);
     }
   }
 
  private:
-  bool dominatedBySlowTreeWalk(const DomTreeNodeBase<NodeT> *A,
-                               const DomTreeNodeBase<NodeT> *B) const {
+  bool dominatedBySlowTreeWalk(const DomTreeNodeOnView<NodeT, View> *A,
+                               const DomTreeNodeOnView<NodeT, View> *B) const {
     assert(A != B);
     assert(isReachableFromEntry(B));
     assert(isReachableFromEntry(A));
 
     const unsigned ALevel = A->getLevel();
-    const DomTreeNodeBase<NodeT> *IDom;
+    const DomTreeNodeOnView<NodeT, View> *IDom;
 
     // Don't walk nodes above A's subtree. When we reach A's level, we must
     // either find A or be in some other subtree not dominated by A.
@@ -912,16 +925,22 @@ class DominatorTreeBase {
   }
 };
 
+template <typename T, template<typename> class View>
+using DomTreeOnView = DominatorTreeOnView<T, false, View>;
+
 template <typename T>
-using DomTreeBase = DominatorTreeBase<T, false>;
+using DomTreeBase = DomTreeOnView<T, DTIdentityView>;
+
+template <typename T, template<typename> class View>
+using PostDomTreeOnView = DominatorTreeOnView<T, true, View>;
 
 template <typename T>
-using PostDomTreeBase = DominatorTreeBase<T, true>;
+using PostDomTreeBase = PostDomTreeOnView<T, DTIdentityView>;
 
 // These two functions are declared out of line as a workaround for building
 // with old (< r147295) versions of clang because of pr11642.
-template <typename NodeT, bool IsPostDom>
-bool DominatorTreeBase<NodeT, IsPostDom>::dominates(const NodeT *A,
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+bool DominatorTreeOnView<NodeT, IsPostDom, View>::dominates(const NodeT *A,
                                                     const NodeT *B) const {
   if (A == B)
     return true;
@@ -932,8 +951,8 @@ bool DominatorTreeBase<NodeT, IsPostDom>::dominates(const NodeT *A,
   return dominates(getNode(const_cast<NodeT *>(A)),
                    getNode(const_cast<NodeT *>(B)));
 }
-template <typename NodeT, bool IsPostDom>
-bool DominatorTreeBase<NodeT, IsPostDom>::properlyDominates(
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+bool DominatorTreeOnView<NodeT, IsPostDom, View>::properlyDominates(
     const NodeT *A, const NodeT *B) const {
   if (A == B)
     return false;
diff --git a/llvm/include/llvm/Support/GenericDomTreeConstruction.h b/llvm/include/llvm/Support/GenericDomTreeConstruction.h
index 4b59ad1f017f..8f20da1991ec 100644
--- a/llvm/include/llvm/Support/GenericDomTreeConstruction.h
+++ b/llvm/include/llvm/Support/GenericDomTreeConstruction.h
@@ -51,13 +51,13 @@
 namespace llvm {
 namespace DomTreeBuilder {
 
-template <typename DomTreeT>
-struct SemiNCAInfo {
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+struct SemiNCAInfoOnView {
+  using DomTreeT = DominatorTreeOnView<NodeT, IsPostDom, View>;
   using NodePtr = typename DomTreeT::NodePtr;
-  using NodeT = typename DomTreeT::NodeType;
-  using TreeNodePtr = DomTreeNodeBase<NodeT> *;
+  using TreeNode = DomTreeNodeOnView<NodeT, View>;
+  using TreeNodePtr = TreeNode*;
   using RootsT = decltype(DomTreeT::Roots);
-  static constexpr bool IsPostDom = DomTreeT::IsPostDominator;
   using GraphDiffT = GraphDiff<NodePtr, IsPostDom>;
 
   // Information record used by Semi-NCA during tree construction.
@@ -95,7 +95,7 @@ struct SemiNCAInfo {
   using BatchUpdatePtr = BatchUpdateInfo *;
 
   // If BUI is a nullptr, then there's no batch update in progress.
-  SemiNCAInfo(BatchUpdatePtr BUI) : BatchUpdates(BUI) {}
+  SemiNCAInfoOnView(BatchUpdatePtr BUI) : BatchUpdates(BUI) {}
 
   void clear() {
     NumToNode = {nullptr}; // Restore to initial state with a dummy start node.
@@ -107,16 +107,18 @@ struct SemiNCAInfo {
   template <bool Inversed>
   static SmallVector<NodePtr, 8> getChildren(NodePtr N, BatchUpdatePtr BUI) {
     if (BUI)
-      return BUI->PreViewCFG.template getChildren<Inversed>(N);
+      return BUI->PreViewCFG.template getChildren<Inversed, View>(N);
     return getChildren<Inversed>(N);
   }
 
   template <bool Inversed>
   static SmallVector<NodePtr, 8> getChildren(NodePtr N) {
     using DirectedNodeT =
-        std::conditional_t<Inversed, Inverse<NodePtr>, NodePtr>;
-    auto R = children<DirectedNodeT>(N);
-    SmallVector<NodePtr, 8> Res(detail::reverse_if<!Inversed>(R));
+        std::conditional_t<Inversed, Inverse<View<NodePtr>>, View<NodePtr>>;
+    using VectRet = SmallVector<NodePtr, 8>;
+    VectRet Res = VectRet(children<DirectedNodeT>(N));
+    if (not Inversed)
+      std::reverse(Res.begin(), Res.end());
 
     // Remove nullptr children for clang.
     llvm::erase_value(Res, nullptr);
@@ -357,7 +359,7 @@ struct SemiNCAInfo {
       return Roots;
     }
 
-    SemiNCAInfo SNCA(BUI);
+    SemiNCAInfoOnView SNCA(BUI);
 
     // PostDominatorTree always has a virtual root.
     SNCA.addVirtualRoot();
@@ -510,7 +512,7 @@ struct SemiNCAInfo {
     assert(IsPostDom && "This function is for postdominators only");
     LLVM_DEBUG(dbgs() << "Removing redundant roots\n");
 
-    SemiNCAInfo SNCA(BUI);
+    SemiNCAInfoOnView SNCA(BUI);
 
     for (unsigned i = 0; i < Roots.size(); ++i) {
       auto &Root = Roots[i];
@@ -571,7 +573,7 @@ struct SemiNCAInfo {
     }
     // This is rebuilding the whole tree, not incrementally, but PostViewBUI is
     // used in case the caller needs a DT update with a CFGView.
-    SemiNCAInfo SNCA(PostViewBUI);
+    SemiNCAInfoOnView SNCA(PostViewBUI);
 
     // Step #0: Number blocks in depth-first order and initialize variables used
     // in later stages of the algorithm.
@@ -904,7 +906,7 @@ struct SemiNCAInfo {
       return false;
     };
 
-    SemiNCAInfo SNCA(BUI);
+    SemiNCAInfoOnView SNCA(BUI);
     SNCA.runDFS(Root, 0, UnreachableDescender, 0);
     SNCA.runSemiNCA(DT);
     SNCA.attachNewSubtree(DT, Incoming);
@@ -997,7 +999,7 @@ struct SemiNCAInfo {
     LLVM_DEBUG(dbgs() << "\tTop of subtree: " << BlockNamePrinter(ToIDomTN)
                       << "\n");
 
-    SemiNCAInfo SNCA(BUI);
+    SemiNCAInfoOnView SNCA(BUI);
     SNCA.runDFS(ToIDom, 0, DescendBelow, 0);
     LLVM_DEBUG(dbgs() << "\tRunning Semi-NCA\n");
     SNCA.runSemiNCA(DT, Level);
@@ -1064,7 +1066,7 @@ struct SemiNCAInfo {
       return false;
     };
 
-    SemiNCAInfo SNCA(BUI);
+    SemiNCAInfoOnView SNCA(BUI);
     unsigned LastDFSNum =
         SNCA.runDFS(ToTN->getBlock(), 0, DescendAndCollect, 0);
 
@@ -1558,48 +1560,46 @@ struct SemiNCAInfo {
   }
 };
 
-template <class DomTreeT>
-void Calculate(DomTreeT &DT) {
-  SemiNCAInfo<DomTreeT>::CalculateFromScratch(DT, nullptr);
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void Calculate(DominatorTreeOnView<NodeT, IsPostDom, View> &DT) {
+  SemiNCAInfoOnView<NodeT, IsPostDom, View>::CalculateFromScratch(DT, nullptr);
 }
 
-template <typename DomTreeT>
-void CalculateWithUpdates(DomTreeT &DT,
-                          ArrayRef<typename DomTreeT::UpdateType> Updates) {
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void CalculateWithUpdates(DominatorTreeOnView<NodeT, IsPostDom, View> &DT,
+                          ArrayRef<typename DominatorTreeOnView<NodeT, IsPostDom, View>::UpdateType> Updates) {
   // FIXME: Updated to use the PreViewCFG and behave the same as until now.
   // This behavior is however incorrect; this actually needs the PostViewCFG.
-  GraphDiff<typename DomTreeT::NodePtr, DomTreeT::IsPostDominator> PreViewCFG(
+  GraphDiff<typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr, IsPostDom> PreViewCFG(
       Updates, /*ReverseApplyUpdates=*/true);
-  typename SemiNCAInfo<DomTreeT>::BatchUpdateInfo BUI(PreViewCFG);
-  SemiNCAInfo<DomTreeT>::CalculateFromScratch(DT, &BUI);
+  typename SemiNCAInfoOnView<NodeT, IsPostDom, View>::BatchUpdateInfo BUI(PreViewCFG);
+  SemiNCAInfoOnView<NodeT, IsPostDom, View>::CalculateFromScratch(DT, &BUI);
 }
 
-template <class DomTreeT>
-void InsertEdge(DomTreeT &DT, typename DomTreeT::NodePtr From,
-                typename DomTreeT::NodePtr To) {
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void InsertEdge(DominatorTreeOnView<NodeT, IsPostDom, View> &DT, typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr From,
+                typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr To) {
   if (DT.isPostDominator()) std::swap(From, To);
-  SemiNCAInfo<DomTreeT>::InsertEdge(DT, nullptr, From, To);
+  SemiNCAInfoOnView<NodeT, IsPostDom, View>::InsertEdge(DT, nullptr, From, To);
 }
 
-template <class DomTreeT>
-void DeleteEdge(DomTreeT &DT, typename DomTreeT::NodePtr From,
-                typename DomTreeT::NodePtr To) {
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void DeleteEdge(DominatorTreeOnView<NodeT, IsPostDom, View> &DT, typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr From,
+                typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr To) {
   if (DT.isPostDominator()) std::swap(From, To);
-  SemiNCAInfo<DomTreeT>::DeleteEdge(DT, nullptr, From, To);
+  SemiNCAInfoOnView<NodeT, IsPostDom, View>::DeleteEdge(DT, nullptr, From, To);
 }
 
-template <class DomTreeT>
-void ApplyUpdates(DomTreeT &DT,
-                  GraphDiff<typename DomTreeT::NodePtr,
-                            DomTreeT::IsPostDominator> &PreViewCFG,
-                  GraphDiff<typename DomTreeT::NodePtr,
-                            DomTreeT::IsPostDominator> *PostViewCFG) {
-  SemiNCAInfo<DomTreeT>::ApplyUpdates(DT, PreViewCFG, PostViewCFG);
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+void ApplyUpdates(DominatorTreeOnView<NodeT, IsPostDom, View> &DT,
+                  GraphDiff<typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr, IsPostDom> &PreViewCFG,
+                  GraphDiff<typename DominatorTreeOnView<NodeT, IsPostDom, View>::NodePtr, IsPostDom> *PostViewCFG) {
+  SemiNCAInfoOnView<NodeT, IsPostDom, View>::ApplyUpdates(DT, PreViewCFG, PostViewCFG);
 }
 
-template <class DomTreeT>
-bool Verify(const DomTreeT &DT, typename DomTreeT::VerificationLevel VL) {
-  SemiNCAInfo<DomTreeT> SNCA(nullptr);
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+bool Verify(const DominatorTreeOnView<NodeT, IsPostDom, View> &DT, typename DominatorTreeOnView<NodeT, IsPostDom, View>::VerificationLevel VL) {
+  SemiNCAInfoOnView<NodeT, IsPostDom, View> SNCA(nullptr);
 
   // Simplist check is to compare against a new tree. This will also
   // usefully print the old and new trees, if they are different.
@@ -1611,12 +1611,12 @@ bool Verify(const DomTreeT &DT, typename DomTreeT::VerificationLevel VL) {
       !SNCA.VerifyLevels(DT) || !SNCA.VerifyDFSNumbers(DT))
     return false;
 
-  // Extra checks depending on VerificationLevel. Up to O(N^3).
-  if (VL == DomTreeT::VerificationLevel::Basic ||
-      VL == DomTreeT::VerificationLevel::Full)
+  // Extra checks depending on VerificationLevel. Up to O(N^3)
+  if (VL == DominatorTreeOnView<NodeT, IsPostDom, View>::VerificationLevel::Basic ||
+      VL == DominatorTreeOnView<NodeT, IsPostDom, View>::VerificationLevel::Full)
     if (!SNCA.verifyParentProperty(DT))
       return false;
-  if (VL == DomTreeT::VerificationLevel::Full)
+  if (VL == DominatorTreeOnView<NodeT, IsPostDom, View>::VerificationLevel::Full)
     if (!SNCA.verifySiblingProperty(DT))
       return false;
 
diff --git a/llvm/include/llvm/Support/raw_ostream.h b/llvm/include/llvm/Support/raw_ostream.h
index 7d572fe06f6f..2ff398d691f7 100644
--- a/llvm/include/llvm/Support/raw_ostream.h
+++ b/llvm/include/llvm/Support/raw_ostream.h
@@ -221,6 +221,15 @@ class raw_ostream {
     return this->operator<<(StringRef(Str));
   }
 
+#if __cpp_char8_t
+  raw_ostream &operator<<(const char8_t *Str) {
+    // Inline fast path, particularly for constant strings where a sufficiently
+    // smart compiler will simplify strlen.
+
+    return this->operator<<(StringRef(Str));
+  }
+#endif
+
   raw_ostream &operator<<(const std::string &Str) {
     // Avoid the fast path, it would only increase code size for a marginal win.
     return write(Str.data(), Str.length());
diff --git a/llvm/include/llvm/Transforms/Utils/LoopUtils.h b/llvm/include/llvm/Transforms/Utils/LoopUtils.h
index 951660bbab28..e2df311cb60e 100644
--- a/llvm/include/llvm/Transforms/Utils/LoopUtils.h
+++ b/llvm/include/llvm/Transforms/Utils/LoopUtils.h
@@ -20,8 +20,17 @@
 
 namespace llvm {
 
-template <typename T> class DomTreeNodeBase;
+template<typename X>
+using DTIdentityView = X;
+
+template <typename NodeT, template<typename> class View>
+class DomTreeNodeOnView;
+
+template <typename NodeT>
+using DomTreeNodeBase = DomTreeNodeOnView<NodeT, DTIdentityView>;
+
 using DomTreeNode = DomTreeNodeBase<BasicBlock>;
+
 class AAResults;
 class AliasSet;
 class AliasSetTracker;
diff --git a/llvm/lib/Analysis/MemorySSAUpdater.cpp b/llvm/lib/Analysis/MemorySSAUpdater.cpp
index 99fa58b8872a..4737c40948f3 100644
--- a/llvm/lib/Analysis/MemorySSAUpdater.cpp
+++ b/llvm/lib/Analysis/MemorySSAUpdater.cpp
@@ -876,7 +876,7 @@ void MemorySSAUpdater::applyInsertUpdates(ArrayRef<CFGUpdate> Updates,
       // Check number of predecessors, we only care if there's more than one.
       unsigned Count = 0;
       BasicBlock *Pred = nullptr;
-      for (auto *Pi : GD->template getChildren</*InverseEdge=*/true>(BB)) {
+      for (auto *Pi : GD->template getChildren</*InverseEdge=*/true, DTIdentityView>(BB)) {
         Pred = Pi;
         Count++;
         if (Count == 2)
@@ -970,7 +970,7 @@ void MemorySSAUpdater::applyInsertUpdates(ArrayRef<CFGUpdate> Updates,
     auto *BB = BBPredPair.first;
     const auto &AddedBlockSet = BBPredPair.second.Added;
     auto &PrevBlockSet = BBPredPair.second.Prev;
-    for (auto *Pi : GD->template getChildren</*InverseEdge=*/true>(BB)) {
+    for (auto *Pi : GD->template getChildren</*InverseEdge=*/true, DTIdentityView>(BB)) {
       if (!AddedBlockSet.count(Pi))
         PrevBlockSet.insert(Pi);
       EdgeCountMap[{Pi, BB}]++;
@@ -1121,7 +1121,7 @@ void MemorySSAUpdater::applyInsertUpdates(ArrayRef<CFGUpdate> Updates,
         for (unsigned I = 0, E = IDFPhi->getNumIncomingValues(); I < E; ++I)
           IDFPhi->setIncomingValue(I, GetLastDef(IDFPhi->getIncomingBlock(I)));
       } else {
-        for (auto *Pi : GD->template getChildren</*InverseEdge=*/true>(BBIDF))
+        for (auto *Pi : GD->template getChildren</*InverseEdge=*/true, DTIdentityView>(BBIDF))
           IDFPhi->addIncoming(GetLastDef(Pi), Pi);
       }
     }
diff --git a/llvm/lib/CodeGen/MachineDominators.cpp b/llvm/lib/CodeGen/MachineDominators.cpp
index c8845d838282..3c8d79644001 100644
--- a/llvm/lib/CodeGen/MachineDominators.cpp
+++ b/llvm/lib/CodeGen/MachineDominators.cpp
@@ -33,8 +33,8 @@ static cl::opt<bool, true> VerifyMachineDomInfoX(
     cl::desc("Verify machine dominator info (time consuming)"));
 
 namespace llvm {
-template class DomTreeNodeBase<MachineBasicBlock>;
-template class DominatorTreeBase<MachineBasicBlock, false>; // DomTreeBase
+template class DomTreeNodeOnView<MachineBasicBlock, DTIdentityView>;
+template class DominatorTreeOnView<MachineBasicBlock, false, DTIdentityView>; // DomTreeBase
 }
 
 char MachineDominatorTree::ID = 0;
diff --git a/llvm/lib/CodeGen/MachinePostDominators.cpp b/llvm/lib/CodeGen/MachinePostDominators.cpp
index fb96d0efa4d4..c13fdbbc1815 100644
--- a/llvm/lib/CodeGen/MachinePostDominators.cpp
+++ b/llvm/lib/CodeGen/MachinePostDominators.cpp
@@ -17,7 +17,7 @@
 using namespace llvm;
 
 namespace llvm {
-template class DominatorTreeBase<MachineBasicBlock, true>; // PostDomTreeBase
+template class DominatorTreeOnView<MachineBasicBlock, true, DTIdentityView>; // PostDomTreeBase
 
 extern bool VerifyMachineDomInfo;
 } // namespace llvm
diff --git a/llvm/lib/IR/Dominators.cpp b/llvm/lib/IR/Dominators.cpp
index fbc28c202aec..86326fdea3cc 100644
--- a/llvm/lib/IR/Dominators.cpp
+++ b/llvm/lib/IR/Dominators.cpp
@@ -63,43 +63,59 @@ bool BasicBlockEdge::isSingleEdge() const {
 //
 //===----------------------------------------------------------------------===//
 
-template class llvm::DomTreeNodeBase<BasicBlock>;
-template class llvm::DominatorTreeBase<BasicBlock, false>; // DomTreeBase
-template class llvm::DominatorTreeBase<BasicBlock, true>; // PostDomTreeBase
+
+namespace llvm {
+
+template <typename NodeT, bool IsPostDom, template<typename> class View>
+class DominatorTreeOnView;
+
+template <typename NodeT, bool IsPostDom>
+using DominatorTreeBase = DominatorTreeOnView<NodeT, IsPostDom, DTIdentityView>;
+
+template <class NodeT, template<typename> class View>
+class DomTreeNodeOnView;
+
+template <class NodeT>
+using DomTreeNodeBase = DomTreeNodeOnView<NodeT, DTIdentityView>;
+
+template class DomTreeNodeOnView<BasicBlock, DTIdentityView>;
+template class DominatorTreeOnView<BasicBlock, false, DTIdentityView>; // DomTree
+template class DominatorTreeOnView<BasicBlock, true, DTIdentityView>; // PostDomTree
+} // end namespace
 
 template class llvm::cfg::Update<BasicBlock *>;
 
-template void llvm::DomTreeBuilder::Calculate<DomTreeBuilder::BBDomTree>(
+template void llvm::DomTreeBuilder::Calculate<BasicBlock, false, DTIdentityView>(
     DomTreeBuilder::BBDomTree &DT);
 template void
-llvm::DomTreeBuilder::CalculateWithUpdates<DomTreeBuilder::BBDomTree>(
+llvm::DomTreeBuilder::CalculateWithUpdates<BasicBlock, false, DTIdentityView>(
     DomTreeBuilder::BBDomTree &DT, BBUpdates U);
 
-template void llvm::DomTreeBuilder::Calculate<DomTreeBuilder::BBPostDomTree>(
+template void llvm::DomTreeBuilder::Calculate<BasicBlock, true, DTIdentityView>(
     DomTreeBuilder::BBPostDomTree &DT);
 // No CalculateWithUpdates<PostDomTree> instantiation, unless a usecase arises.
 
-template void llvm::DomTreeBuilder::InsertEdge<DomTreeBuilder::BBDomTree>(
+template void llvm::DomTreeBuilder::InsertEdge<BasicBlock, false, DTIdentityView>(
     DomTreeBuilder::BBDomTree &DT, BasicBlock *From, BasicBlock *To);
-template void llvm::DomTreeBuilder::InsertEdge<DomTreeBuilder::BBPostDomTree>(
+template void llvm::DomTreeBuilder::InsertEdge<BasicBlock, true, DTIdentityView>(
     DomTreeBuilder::BBPostDomTree &DT, BasicBlock *From, BasicBlock *To);
 
-template void llvm::DomTreeBuilder::DeleteEdge<DomTreeBuilder::BBDomTree>(
+template void llvm::DomTreeBuilder::DeleteEdge<BasicBlock, false, DTIdentityView>(
     DomTreeBuilder::BBDomTree &DT, BasicBlock *From, BasicBlock *To);
-template void llvm::DomTreeBuilder::DeleteEdge<DomTreeBuilder::BBPostDomTree>(
+template void llvm::DomTreeBuilder::DeleteEdge<BasicBlock, true, DTIdentityView>(
     DomTreeBuilder::BBPostDomTree &DT, BasicBlock *From, BasicBlock *To);
 
-template void llvm::DomTreeBuilder::ApplyUpdates<DomTreeBuilder::BBDomTree>(
-    DomTreeBuilder::BBDomTree &DT, DomTreeBuilder::BBDomTreeGraphDiff &,
-    DomTreeBuilder::BBDomTreeGraphDiff *);
-template void llvm::DomTreeBuilder::ApplyUpdates<DomTreeBuilder::BBPostDomTree>(
-    DomTreeBuilder::BBPostDomTree &DT, DomTreeBuilder::BBPostDomTreeGraphDiff &,
-    DomTreeBuilder::BBPostDomTreeGraphDiff *);
+template void
+llvm::DomTreeBuilder::ApplyUpdates<BasicBlock, false, DTIdentityView>(
+    BBDomTree &DT, BBDomTreeGraphDiff &, BBDomTreeGraphDiff *);
+template void
+llvm::DomTreeBuilder::ApplyUpdates<BasicBlock, true, DTIdentityView>(
+    BBPostDomTree &DT, BBPostDomTreeGraphDiff &, BBPostDomTreeGraphDiff *);
 
-template bool llvm::DomTreeBuilder::Verify<DomTreeBuilder::BBDomTree>(
+template bool llvm::DomTreeBuilder::Verify<BasicBlock, false, DTIdentityView>(
     const DomTreeBuilder::BBDomTree &DT,
     DomTreeBuilder::BBDomTree::VerificationLevel VL);
-template bool llvm::DomTreeBuilder::Verify<DomTreeBuilder::BBPostDomTree>(
+template bool llvm::DomTreeBuilder::Verify<BasicBlock, true, DTIdentityView>(
     const DomTreeBuilder::BBPostDomTree &DT,
     DomTreeBuilder::BBPostDomTree::VerificationLevel VL);
 
diff --git a/llvm/lib/Object/XCOFFObjectFile.cpp b/llvm/lib/Object/XCOFFObjectFile.cpp
index a16a458168d4..d719a288981e 100644
--- a/llvm/lib/Object/XCOFFObjectFile.cpp
+++ b/llvm/lib/Object/XCOFFObjectFile.cpp
@@ -166,7 +166,7 @@ XCOFFObjectFile::getStringTableEntry(uint32_t Offset) const {
   // field; as a soft-error recovery mechanism, we treat such cases as having an
   // offset of 0.
   if (Offset < 4)
-    return StringRef(nullptr, 0);
+    return StringRef();
 
   if (StringTable.Data != nullptr && StringTable.Size > Offset)
     return (StringTable.Data + Offset);
diff --git a/llvm/lib/Transforms/Vectorize/VPlan.cpp b/llvm/lib/Transforms/Vectorize/VPlan.cpp
index b26399e0ae58..709ddd291505 100644
--- a/llvm/lib/Transforms/Vectorize/VPlan.cpp
+++ b/llvm/lib/Transforms/Vectorize/VPlan.cpp
@@ -1018,7 +1018,7 @@ void VPWidenCanonicalIVRecipe::print(raw_ostream &O, const Twine &Indent,
   O << " = WIDEN-CANONICAL-INDUCTION";
 }
 
-template void DomTreeBuilder::Calculate<VPDominatorTree>(VPDominatorTree &DT);
+template void DomTreeBuilder::Calculate<VPBlockBase, false, DTIdentityView>(VPDominatorTree &DT);
 
 void VPValue::replaceAllUsesWith(VPValue *New) {
   for (unsigned J = 0; J < getNumUsers();) {
diff --git a/llvm/test/tools/llvm-ar/error-opening-permission.test b/llvm/test/tools/llvm-ar/error-opening-permission.test
deleted file mode 100644
index d8d0cbfd3556..000000000000
--- a/llvm/test/tools/llvm-ar/error-opening-permission.test
+++ /dev/null
@@ -1,14 +0,0 @@
-## Unsupported on windows as marking files "unreadable"
-## is non-trivial on windows.
-# UNSUPPORTED: system-windows
-
-# RUN: rm -rf %t && mkdir -p %t
-# RUN: echo file1 > %t/1.txt
-
-## No Permission:
-# RUN: llvm-ar rc %t/permission.b %t/1.txt
-# RUN: chmod 100 %t/permission.b
-# RUN: not llvm-ar p %t/permission.b 2>&1 | \
-# RUN:   FileCheck %s --check-prefix=NO-PERMISSION -DARCHIVE=%t/permission.b
-
-# NO-PERMISSION: error: unable to open '[[ARCHIVE]]': {{.*}}{{[pP]}}ermission denied
diff --git a/llvm/test/tools/llvm-elfabi/fail-file-write.test b/llvm/test/tools/llvm-elfabi/fail-file-write.test
deleted file mode 100644
index c3c479e73887..000000000000
--- a/llvm/test/tools/llvm-elfabi/fail-file-write.test
+++ /dev/null
@@ -1,18 +0,0 @@
-## Test failing to write output file on non-windows platforms.
-
-# UNSUPPORTED: system-windows
-# RUN: rm -rf %t.TestDir
-# RUN: mkdir %t.TestDir
-# RUN: touch %t.TestDir/Output.TestFile
-# RUN: chmod 400 %t.TestDir
-# RUN: not llvm-elfabi %s --output-target=elf64-little %t.TestDir/Output.TestFile 2>&1 | FileCheck %s --check-prefix=ERR
-# RUN: chmod 777 %t.TestDir
-# RUN: rm -rf %t.TestDir
-
---- !tapi-tbe
-TbeVersion: 1.0
-Arch: AArch64
-Symbols: {}
-...
-
-# ERR: {{.*}}Permission denied{{.*}} when trying to open `{{.*}}.TestDir/Output.TestFile` for writing
diff --git a/llvm/unittests/ADT/APFixedPointTest.cpp b/llvm/unittests/ADT/APFixedPointTest.cpp
index 53fa1cd8b503..8891889c62ee 100644
--- a/llvm/unittests/ADT/APFixedPointTest.cpp
+++ b/llvm/unittests/ADT/APFixedPointTest.cpp
@@ -223,7 +223,7 @@ void CheckIntPartMin(const FixedPointSemantics &Sema, int64_t Expected) {
   ASSERT_EQ(APFixedPoint::getMin(Sema).getIntPart(), Expected);
 }
 
-void CheckIntPartMax(const FixedPointSemantics &Sema, uint64_t Expected) {
+void CheckIntPartMax(const FixedPointSemantics &Sema, int64_t Expected) {
   ASSERT_EQ(APFixedPoint::getMax(Sema).getIntPart(), Expected);
 }
 
diff --git a/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp b/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp
index a2d5805a9874..5e1a8f28527b 100644
--- a/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp
+++ b/llvm/unittests/IR/DominatorTreeBatchUpdatesTest.cpp
@@ -26,8 +26,8 @@ using DomUpdate = DominatorTree::UpdateType;
 static_assert(
     std::is_same<DomUpdate, PostDominatorTree::UpdateType>::value,
     "Trees differing only in IsPostDom should have the same update types");
-using DomSNCA = DomTreeBuilder::SemiNCAInfo<DomTreeBuilder::BBDomTree>;
-using PostDomSNCA = DomTreeBuilder::SemiNCAInfo<DomTreeBuilder::BBPostDomTree>;
+using DomSNCA = DomTreeBuilder::SemiNCAInfoOnView<BasicBlock, false, DTIdentityView>;
+using PostDomSNCA = DomTreeBuilder::SemiNCAInfoOnView<BasicBlock, true, DTIdentityView>;
 const auto Insert = DominatorTree::Insert;
 const auto Delete = DominatorTree::Delete;
 
diff --git a/llvm/unittests/Support/DJBTest.cpp b/llvm/unittests/Support/DJBTest.cpp
index c01bbe1eaa67..c9d1d9fc5dd2 100644
--- a/llvm/unittests/Support/DJBTest.cpp
+++ b/llvm/unittests/Support/DJBTest.cpp
@@ -18,7 +18,7 @@ TEST(DJBTest, caseFolding) {
     StringLiteral Two;
   };
 
-  static constexpr TestCase Tests[] = {
+  static TestCase Tests[] = {
       {{"ASDF"}, {"asdf"}},
       {{"qWeR"}, {"QwEr"}},
       {{"qqqqqqqqqqqqqqqqqqqq"}, {"QQQQQQQQQQQQQQQQQQQQ"}},
diff --git a/llvm/unittests/Support/JSONTest.cpp b/llvm/unittests/Support/JSONTest.cpp
index ed9a72d36b06..2168f170f8f3 100644
--- a/llvm/unittests/Support/JSONTest.cpp
+++ b/llvm/unittests/Support/JSONTest.cpp
@@ -174,12 +174,12 @@ TEST(JSONTest, Parse) {
   Compare(R"("\"\\\b\f\n\r\t")", "\"\\\b\f\n\r\t");
   Compare(R"("\u0000")", llvm::StringRef("\0", 1));
   Compare("\"\x7f\"", "\x7f");
-  Compare(R"("\ud801\udc37")", u8"\U00010437"); // UTF16 surrogate pair escape.
-  Compare("\"\xE2\x82\xAC\xF0\x9D\x84\x9E\"", u8"\u20ac\U0001d11e"); // UTF8
+  Compare(R"("\ud801\udc37")", reinterpret_cast<const char *>(u8"\U00010437")); // UTF16 surrogate pair escape.
+  Compare("\"\xE2\x82\xAC\xF0\x9D\x84\x9E\"", reinterpret_cast<const char *>(u8"\u20ac\U0001d11e")); // UTF8
   Compare(
       R"("LoneLeading=\ud801, LoneTrailing=\udc01, LeadingLeadingTrailing=\ud801\ud801\udc37")",
-      u8"LoneLeading=\ufffd, LoneTrailing=\ufffd, "
-      u8"LeadingLeadingTrailing=\ufffd\U00010437"); // Invalid unicode.
+      reinterpret_cast<const char *>(u8"LoneLeading=\ufffd, LoneTrailing=\ufffd, "
+                                     u8"LeadingLeadingTrailing=\ufffd\U00010437")); // Invalid unicode.
 
   Compare(R"({"":0,"":0})", Object{{"", 0}});
   Compare(R"({"obj":{},"arr":[]})", Object{{"obj", Object{}}, {"arr", {}}});