Make LLVM build in C++20 mode

[BRevzin]

Summary

Part of the <=> changes in C++20 make certain patterns of writing equality operators ambiguous with themselves (sorry!). This review goes through and adjusts all the comparison operators such that they should work in both C++17 and C++20 modes. It also makes two other small C++20-specific changes (adding a constructor to a type that cases to be an aggregate, and adding casts from u8 literals which no longer have type const char*)

There were four categories of errors that this review fixes. Here are canonical examples of them, ordered from most to least common, which you can view on compiler-explorer:

#include <utility>

// 1) Missing const
namespace missing_const {
    struct A {
    #ifndef FIXED
        bool operator==(A const&);
    #else
        bool operator==(A const&) const;
    #endif
    };

    bool a = A{} == A{}; // error
}

// 2) Type mismatch on CRTP
namespace crtp_mismatch {
    template <typename Derived>
    struct Base {
    #ifndef FIXED
        bool operator==(Derived const&) const;
    #else
        // in one case changed to taking Base const&
        friend bool operator==(Derived const&, Derived const&);
    #endif
    };

    struct D : Base<D> { };

    bool b = D{} == D{}; // error
}

// 3) iterator/const_iterator with only mixed comparison
namespace iter_const_iter {
    template <bool Const>
    struct iterator {
        using const_iterator = iterator<true>;

        iterator();

        template <bool B, std::enable_if_t<(Const && !B), int> = 0>
        iterator(iterator<B> const&);

    #ifndef FIXED
        bool operator==(const_iterator const&) const;
    #else
        friend bool operator==(iterator const&, iterator const&);
    #endif
    };
    
    bool c = iterator<false>{} == iterator<false>{} // error
          || iterator<false>{} == iterator<true>{}
          || iterator<true>{} == iterator<false>{}
          || iterator<true>{} == iterator<true>{};
}

// 4) Same-type comparison but only have mixed-type operator
namespace ambiguous_choice {
    enum Color { Red };

    struct C {
        C();
        C(Color);
        operator Color() const;
        bool operator==(Color) const;
#ifdef FIXED
        friend bool operator==(C, C);
#endif
    };

    bool c = C{} == C{}; // error
    bool d = C{} == Red;
}

[• Quuxplusone]

llvm/include/llvm/Support/BinaryStreamRef.h

124–125

Is there a neat rule of thumb for when you were able to preserve the member bool Me::operator==(const Me& rhs) const versus when you were forced to change it to a hidden friend? It seems like maybe you changed it to a hidden friend only in cases where Me was a base class, is that right?

[rsmith]

clang/lib/Parse/ParseOpenMP.cpp

64–67

Comparing against V.Value here would seem more idiomatic than invoking operator unsigned.

69–70

Do we still need these?

[BRevzin]

More idiomatic comparison implementation.

[BRevzin]

clang/lib/Parse/ParseOpenMP.cpp

69–70

Yep. This type is compared to both itself and the enum, so both are necessary.

[BRevzin]

Wtf, where'd my other changes go?

[hubert.reinterpretcast]

In D78938#2006715, @BRevzin wrote:

Wtf, where'd my other changes go?

I've hit this before, use arc diff --update D78938 <base_branch>.

[BRevzin]

Trying this again.

[BRevzin]

In D78938#2006758, @hubert.reinterpretcast wrote:

In D78938#2006715, @BRevzin wrote:

Wtf, where'd my other changes go?

I've hit this before, use arc diff --update D78938 <base_branch>.

Thanks Hubert!

[dblaikie]

(peanut gallery: I'd consider, while you're touching these all anyway, changing them all to non-member (friended where required) as I believe that's best practice - allows equal implicit conversions on either side, for instance (even if some types have no implicit conversions - it at least provides a nice consistency/examples that people are likely to copy from))

[BRevzin]

In D78938#2007037, @dblaikie wrote:

(peanut gallery: I'd consider, while you're touching these all anyway, changing them all to non-member (friended where required) as I believe that's best practice - allows equal implicit conversions on either side, for instance (even if some types have no implicit conversions - it at least provides a nice consistency/examples that people are likely to copy from))

Hidden friend is probably the best way to write comparisons in C++17 and earlier, but I'm not sure that will hold in C++20 (even if LLVM isn't on C++20 and won't be for I imagine quite some time). With reversed candidates, I think member functions might be the way to go there - you still get implicit conversions on either side (just not on both sides at the same time) and hidden friends... are kind of weird, to be honest.

Also, I didn't touch all of them - only the ones that break in C++20 (a lot of which just missing a const). A lot of comparison operators are already fine. I'm not sure it's worth changing them just to look the same.

[dblaikie]

In D78938#2007571, @BRevzin wrote:

In D78938#2007037, @dblaikie wrote:

(peanut gallery: I'd consider, while you're touching these all anyway, changing them all to non-member (friended where required) as I believe that's best practice - allows equal implicit conversions on either side, for instance (even if some types have no implicit conversions - it at least provides a nice consistency/examples that people are likely to copy from))

Hidden friend is probably the best way to write comparisons in C++17 and earlier, but I'm not sure that will hold in C++20 (even if LLVM isn't on C++20 and won't be for I imagine quite some time). With reversed candidates, I think member functions might be the way to go there - you still get implicit conversions on either side (just not on both sides at the same time) and hidden friends... are kind of weird, to be honest.

Yeah, probably just experience with things the way they've been, but the symmetry is kind of nice without relying on deeper aspects of the newer features (& the benefit of the code being more suitable for C++17, where LLVM is currently).

Also, I didn't touch all of them - only the ones that break in C++20 (a lot of which just missing a const). A lot of comparison operators are already fine. I'm not sure it's worth changing them just to look the same.

Yeah - just meant the ones you are touching, might be nice to move them in that direction.

Anyway, I'll leave it to you/other reviewers - no /super/ strong feelings here.

[jfb]

This seems fine, assuming you've run usual tests?

[davidstone]

llvm/include/llvm/ADT/DirectedGraph.h

99

Missing return

[BRevzin]

• A few more changes from tests.

[BRevzin]

• Adding missing return.

[BRevzin]

I hadn't build the tests before, updated with a few more changes. Some of the tests require u8 literals, whose type changes in C++20. I had no idea what to do with that, so I just #ifdef-ed out those tests with the appropriate feature test macro.

[BRevzin]

• Backing out changes that aren't strictly comparison-related.

[jfb]

One suggestions, otherwise looks good. Thanks for doing this :)

llvm/include/llvm/ADT/DirectedGraph.h

40–41

That comment, so informative! 😐

99

😱

Did this not trigger a diagnostic when building? I wonder if it's just not on?

llvm/unittests/ADT/STLExtrasTest.cpp

466

Can you add a comment above (with "fancy pointer") so mere mortals understand the parens?

[davidstone]

I noticed the missing return because there is a warning (not as error) that caught it, I think the warning about falling off the end of a non-void-returning function.

[BRevzin]

• Explaining the cryptic parentheses.

llvm/include/llvm/ADT/DirectedGraph.h

99

Yeah I was surprised too. I'm compiling with -Wall -Wextra...

[BRevzin]

Updating this review with some additional changes that need to be made since I last touched it, and some of the previous changes had inadvertently broken the C++14 build so fixing those as well.

[jhenderson]

Not that I have anything particularly against this, but won't this likely rot fairly rapidly? It's not like LLVM is even on C++17 let alone C++20 yet, so trying to make it work like the latter when it's just going to break again seems a bit like wasted effort to me.

llvm/tools/llvm-objdump/llvm-objdump.cpp

805–817 ↗

(On Diff #290023)

This seems unrelated to comparison checking?

llvm/unittests/ADT/STLExtrasTest.cpp

465

Nit: trailing full stop.

[BRevzin]

In D78938#2258557, @jhenderson wrote:

Not that I have anything particularly against this, but won't this likely rot fairly rapidly? It's not like LLVM is even on C++17 let alone C++20 yet, so trying to make it work like the latter when it's just going to break again seems a bit like wasted effort to me.

People will want to write C++20 programs that use LLVM headers, so I think it's important to help let them do that. Sure, it may rot, but incremental fixes down the line will be smaller.

[BRevzin]

llvm/tools/llvm-objdump/llvm-objdump.cpp

805–817 ↗

(On Diff #290023)

This seems unrelated to comparison checking?

It is unrelated. But In C++20, u8 literals become their own type so this no longer compiled and I wanted to ensure that I could actually run the tests.

[jhenderson]

In D78938#2259342, @BRevzin wrote:

In D78938#2258557, @jhenderson wrote:

Not that I have anything particularly against this, but won't this likely rot fairly rapidly? It's not like LLVM is even on C++17 let alone C++20 yet, so trying to make it work like the latter when it's just going to break again seems a bit like wasted effort to me.

People will want to write C++20 programs that use LLVM headers, so I think it's important to help let them do that. Sure, it may rot, but incremental fixes down the line will be smaller.

Makes sense, thanks.

llvm/tools/llvm-objdump/llvm-objdump.cpp

805–817 ↗

(On Diff #290023)

Could it be a pre-requisite patch then?

[jfb]

On C++20 mode rotting: it won't if someone sets up a bot. If it rots, then it's easier to un-rot with Barry's patch.

llvm/tools/llvm-objdump/llvm-objdump.cpp

805–817 ↗

(On Diff #290023)

I'm fine with this if the patch title is changed to "make LLVM build in C++20 mode", and description edited accordingly. Basically, it makes it easy to figure out which changes were done for C++20.

[jhenderson]

In D78938#2261411, @jfb wrote:

On C++20 mode rotting: it won't if someone sets up a bot. If it rots, then it's easier to un-rot with Barry's patch.

I assume this would be a private bot? It can't be a public bot, since LLVM isn't even on C++17, let alone C++20, and so it shouldn't be part of minimum requirements that somebody has a compiler that can build C++20. Whilst I personally am quite happy with moving LLVM forward, I develop on Windows primarily, so don't have the same need to support a long tail of old *nix versions etc.

@BRevzin, you should a) mention the u8/const char* issue in the description too, and also what compiler you used to build this with. I fully expect at this stage that there are some C++20 compilers that might have slightly different interpretations of things which this won't resolve, so knowing which one this is intended to work with could help with historical research.

[BRevzin]

@BRevzin, you should a) mention the u8/const char* issue in the description too, and also what compiler you used to build this with. I fully expect at this stage that there are some C++20 compilers that might have slightly different interpretations of things which this won't resolve, so knowing which one this is intended to work with could help with historical research.

It's mentioned in the description. I built with clang-10.

[dblaikie]

In D78938#2262713, @jhenderson wrote:

In D78938#2261411, @jfb wrote:

On C++20 mode rotting: it won't if someone sets up a bot. If it rots, then it's easier to un-rot with Barry's patch.

I assume this would be a private bot? It can't be a public bot, since LLVM isn't even on C++17, let alone C++20, and so it shouldn't be part of minimum requirements that somebody has a compiler that can build C++20. Whilst I personally am quite happy with moving LLVM forward, I develop on Windows primarily, so don't have the same need to support a long tail of old *nix versions etc.

I'd be fine with it being a public bot - it's not saying LLVM can only be compiled with C++20-supporting compilers, that'd be very different & that's the discussion we'll have when we want to start using C++20 in LLVM. But saying "LLVM is intended to be C++20 compatible" is something we can/shuold be saying much sooner than that. Like we say that LLVM's compatible with a certain variety of compilers in C++14 mode too - not everyone has or is testing on all those compilers every time they commit, but buildbots test a range of them (and test a range of hardware - again, hardware I don't have/don't intend to test with) & we clean things up that they report, ideally.

I'd think a C++20 buildbot could at least be relatively fast/easy (doesn't have to do multi-stage bootstraps (though it could - making sure the evolving C++20 support in Clang remains compatible with the LLVM project codebase itself)) - doesn't even need to run any tests, really, just compile.

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

167–171 ↗

(On Diff #290023)

Why are some being removed? That seems harder to justify. Even if they're not called, it may be more valuable to have the symmetry to reduce friction if/when they are needed. (iterators seem pretty common to compare for inequality - such as in a loop condition testing I != E)

llvm/include/llvm/IR/BasicBlock.h

317–318

What tripped over/required this SFINAE?

llvm/include/llvm/Support/BinaryStreamRef.h

124–125

Be curious of the answer here - and, honestly, I'd be fine with changing them all to friends. It makes them more consistent - equal rank for implicit conversions on LHS and RHS, etc. (generally considered best practice basically to not define op overloads as members if they can be defined as non-members)

llvm/unittests/ADT/STLExtrasTest.cpp

465

Probably more suitable to use qualify the name rather than use parens (teh comment's still helpful to explain why either strategy is used) - that's what's done with llvm::make_unique, for instance.

[BRevzin]

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

167–171 ↗

(On Diff #290023)

They're not being removed. These functions still exist - it's just that now they're being injected by the base class template with this exact signature (rather than before where they were slightly different), so that now these are redefinition issues.

There's no loss of functionality here.

llvm/include/llvm/IR/BasicBlock.h

317–318

There's somewhere which compared a const iterator to a non-const iterator, that ends up doing conversions in both directions under C++20 rules, one direction of which is perfectly fine and the other was a hard error. Need to make the non-const iterator not constructible from a const iterator.

[dblaikie]

llvm/include/llvm/IR/BasicBlock.h

317–318

Is this true for all iterators? Or some quirk of how this one is written/used (that could be fixed/changed there instead)?

[• Quuxplusone]

llvm/include/llvm/IR/BasicBlock.h

317–318

IMO there is a (much) bigger task hiding here, which is to audit every type in the codebase whose name contains the string "Iterator" and compare them to the C++20 Ranges std::forward_iterator concept. My impression is that the vast majority of real-world "iterator types" are not iterators according to C++20 Ranges, and that this can have arbitrarily weird effects when you mix them with the C++20 STL.

However, that is massive scope creep re this particular patch. I think the larger question of "do all our iterators need X / are all our iterators written wrong" should be scoped-outside-of this patch.

[dblaikie]

llvm/include/llvm/IR/BasicBlock.h

317–318

Sorry, not suggesting that kind of scope creep - but do want to understand whether this is representative of the way code should generally be written, or whether this is working around some other issue/different fix.

[BRevzin]

llvm/include/llvm/IR/BasicBlock.h

317–318

So I undid this change to copy the exact issue that I ran into. But it actually ended up still compiling anyway. Part of the issue might be that I keep futzing with the cmake configuration since it takes me more than an hour to compile, so maybe there's some target that needed this change that I no longer compile.

But the kind of problem I think this had was:

template <typename T>
struct iterator {
    T* p;
    
    template <typename U>
    iterator(iterator<U> rhs)
        : p(rhs.p)
    { } 

    bool operator==(iterator const& rhs);
};

bool check(iterator<int const> a, iterator<int> b) {
    return a == b;
}

which compiles fine in C++17 but is ambiguous in C++20 because b.operator==(a) is also a candidate (even though it's not _really_ a candidate, and would be a hard error if selected). the sfinae removes the bad candidate from the set.

It's true for all iterators in general in that you want const_iterator constructible from iterator but not the reverse (unless they're the same type).

[lebedev.ri]

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

167–171 ↗

(On Diff #290023)

Does LLVM still build fine in C++14/C++17 modes afterwards?

[BRevzin]

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

167–171 ↗

(On Diff #290023)

Yes.

[dblaikie]

llvm/include/llvm/IR/BasicBlock.h

317–318

Fair enough - don't mind keeping it in then.

llvm/include/llvm/Support/BinaryStreamRef.h

124–125

Ping on this (& I'd usually call the parameters LHS and RHS rather than Self and Other)

llvm/unittests/ADT/STLExtrasTest.cpp

465

Ping on this.

[nlopes]

Thanks @lebedev.ri for the pointer!
I started working on exactly the same thing as I was trying to link a C++20 project with LLVM.
@BRevzin is there anything missing in this patch? Do you have commit access or do you need help to land this?

[MaskRay]

@BRevzin Please share your name and email if you want someone to commit it for you https://llvm.org/docs/DeveloperPolicy.html#commit-messages

[BRevzin]

In D78938#2450915, @nlopes wrote:

Thanks @lebedev.ri for the pointer!
I started working on exactly the same thing as I was trying to link a C++20 project with LLVM.
@BRevzin is there anything missing in this patch? Do you have commit access or do you need help to land this?

There are two comments that @dblaikie made that need to still be addressed (one about renaming parameters of a function from Self and Other to LHS and RHS, and one about changing the ADL-inhibition strategy from (to_address)(x) to llvm::to_address(x)), both of which combined should take about a minute to do and then however long to compile.

I've forgotten how to push changes and am kind of confused at the state of my current branch anyway, and it takes so long to do anything on my laptop that I'm more than happy to let you take over. I do not have commit access anyway.

Per @MaskRay, I'm Barry Revzin <[e-mail]>.

[RKSimon]

@BRevzin @nlopes This is causing MSVC build failure please can you take a look?

E:\llvm\llvm-project\llvm\include\llvm/DebugInfo/DWARF/DWARFDie.h(405): note: see declaration of 'std::reverse_iterator<llvm::DWARFDie::iterator>'
E:\llvm\llvm-project\llvm\lib\DWARFLinker\DWARFLinker.cpp(383): note: see reference to function template instantiation 'bool std::operator !=<llvm::DWARFDie::iterator,llvm::DWARFDie::iterator>(const std::reverse_iterator<llvm::DWARFDie::iterator> &,const std::reverse_iterator<llvm::DWARFDie::iterator> &)' being compiled
C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.28.29333\include\xutility(2086): error C2039: '_Get_current': is not a member of 'std::reverse_iterator<llvm::DWARFDie::iterator>'
E:\llvm\llvm-project\llvm\include\llvm/DebugInfo/DWARF/DWARFDie.h(405): note: see declaration of 'std::reverse_iterator<llvm::DWARFDie::iterator>'

[nlopes]

In D78938#2459973, @RKSimon wrote:

@BRevzin @nlopes This is causing MSVC build failure please can you take a look?

E:\llvm\llvm-project\llvm\include\llvm/DebugInfo/DWARF/DWARFDie.h(405): note: see declaration of 'std::reverse_iterator<llvm::DWARFDie::iterator>'
E:\llvm\llvm-project\llvm\lib\DWARFLinker\DWARFLinker.cpp(383): note: see reference to function template instantiation 'bool std::operator !=<llvm::DWARFDie::iterator,llvm::DWARFDie::iterator>(const std::reverse_iterator<llvm::DWARFDie::iterator> &,const std::reverse_iterator<llvm::DWARFDie::iterator> &)' being compiled
C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Tools\MSVC\14.28.29333\include\xutility(2086): error C2039: '_Get_current': is not a member of 'std::reverse_iterator<llvm::DWARFDie::iterator>'
E:\llvm\llvm-project\llvm\include\llvm/DebugInfo/DWARF/DWARFDie.h(405): note: see declaration of 'std::reverse_iterator<llvm::DWARFDie::iterator>'

Just saw that you fixed it already. Thank you!

[RKSimon]

In D78938#2460360, @nlopes wrote:

Just saw that you fixed it already. Thank you!

'Avoided' might be a better term than 'fixed' tbh - I didn't delve much into why it was breaking, or what effect it has on C++20 work.

[bmahjour]

llvm/include/llvm/ADT/DirectedGraph.h

40–41

It would be better to make these non-member functions as well, to be consistent with the DGNode.

friend bool operator==(const EdgeType &Elhs, const EdgeType &Erhs) {
  return Elhs.isEqualTo(Erhs);
}
friend bool operator!=(const EdgeType &Elhs, const EdgeType &Erhs) {
  return !(Elhs == Erhs);
}

40–41

That comment, so informative! 😐

Yeah, it's not the best comment. It is trying to say that the isEqualTo function gets selected, based on the type of the derived class in the CRTP, and that the selection is done at compile-time using type information, rather than at runtime using dynamic polymorphism. Please feel free to update it to say that or offer any other suggestions you might have.

clang/include/clang/AST/StmtIterator.h

public:
   }
 
   DERIVED operator++(int) {
     DERIVED tmp = static_cast<DERIVED&>(*this);
     operator++();
     return tmp;
   }
 
-  bool operator==(const DERIVED& RHS) const {
-    return stmt == RHS.stmt && DGI == RHS.DGI && RawVAPtr == RHS.RawVAPtr;
+  friend bool operator==(const DERIVED &LHS, const DERIVED &RHS) {
+    return LHS.stmt == RHS.stmt && LHS.DGI == RHS.DGI &&
+           LHS.RawVAPtr == RHS.RawVAPtr;
   }
 
-  bool operator!=(const DERIVED& RHS) const {
-    return stmt != RHS.stmt || DGI != RHS.DGI || RawVAPtr != RHS.RawVAPtr;
+  friend bool operator!=(const DERIVED &LHS, const DERIVED &RHS) {
+    return !(LHS == RHS);
   }
 
   REFERENCE operator*() const {
     return inStmt() ? *stmt : GetDeclExpr();
   }
 
   REFERENCE operator->() const { return operator*(); }
 };

clang/lib/Parse/ParseOpenMP.cpp

 };
 
 // Helper to unify the enum class OpenMPDirectiveKind with its extension
 // the OpenMPDirectiveKindEx enum which allows to use them together as if they
 // are unsigned values.
 struct OpenMPDirectiveKindExWrapper {
   OpenMPDirectiveKindExWrapper(unsigned Value) : Value(Value) {}
   OpenMPDirectiveKindExWrapper(OpenMPDirectiveKind DK) : Value(unsigned(DK)) {}
+  bool operator==(OpenMPDirectiveKindExWrapper V) const {
+    return Value == V.Value;
+  }
+  bool operator!=(OpenMPDirectiveKindExWrapper V) const {
+    return Value != V.Value;
+  }
   bool operator==(OpenMPDirectiveKind V) const { return Value == unsigned(V); }
   bool operator!=(OpenMPDirectiveKind V) const { return Value != unsigned(V); }
   bool operator<(OpenMPDirectiveKind V) const { return Value < unsigned(V); }
   operator unsigned() const { return Value; }
   operator OpenMPDirectiveKind() const { return OpenMPDirectiveKind(Value); }
   unsigned Value;
 };
 
 class DeclDirectiveListParserHelper final {
   SmallVector<Expr *, 4> Identifiers;

clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp

private:
   mutable std::unique_ptr<BugType> BT;
   void initBugType() const {
     if (!BT)
       BT = std::make_unique<BugType>(this, "Use of Untrusted Data",
                                      "Untrusted Data");
   }
 
   struct FunctionData {
-    FunctionData() = delete;
+    FunctionData(const FunctionDecl *FDecl, StringRef Name,
+                 std::string FullName)
+        : FDecl(FDecl), Name(Name), FullName(std::move(FullName)) {}
+
     FunctionData(const FunctionData &) = default;
     FunctionData(FunctionData &&) = default;
     FunctionData &operator=(const FunctionData &) = delete;
     FunctionData &operator=(FunctionData &&) = delete;
 
     static Optional<FunctionData> create(const CallEvent &Call,
                                          const CheckerContext &C) {
       if (!Call.getDecl())

llvm/include/llvm/ADT/AllocatorList.h

IteratorImpl(const IteratorImpl<OtherValueT, OtherIteratorBase> &X,
                  std::enable_if_t<std::is_convertible<
                      OtherIteratorBase, IteratorBase>::value> * = nullptr)
         : base_type(X.wrapped()) {}
 
     ~IteratorImpl() = default;
 
     reference operator*() const { return base_type::wrapped()->V; }
     pointer operator->() const { return &operator*(); }
-
-    friend bool operator==(const IteratorImpl &L, const IteratorImpl &R) {
-      return L.wrapped() == R.wrapped();
-    }
-    friend bool operator!=(const IteratorImpl &L, const IteratorImpl &R) {
-      return !(L == R);
-    }
   };
 
 public:
   using iterator = IteratorImpl<T, typename list_type::iterator>;
   using reverse_iterator =
       IteratorImpl<T, typename list_type::reverse_iterator>;
   using const_iterator =
       IteratorImpl<const T, typename list_type::const_iterator>;

llvm/include/llvm/ADT/DenseMap.h

public:
   pointer operator->() const {
     assert(isHandleInSync() && "invalid iterator access!");
     assert(Ptr != End && "dereferencing end() iterator");
     if (shouldReverseIterate<KeyT>())
       return &(Ptr[-1]);
     return Ptr;
   }
 
-  bool operator==(const ConstIterator &RHS) const {
-    assert((!Ptr || isHandleInSync()) && "handle not in sync!");
+  friend bool operator==(const DenseMapIterator &LHS,
+                         const DenseMapIterator &RHS) {
+    assert((!LHS.Ptr || LHS.isHandleInSync()) && "handle not in sync!");
     assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
-    assert(getEpochAddress() == RHS.getEpochAddress() &&
+    assert(LHS.getEpochAddress() == RHS.getEpochAddress() &&
            "comparing incomparable iterators!");
-    return Ptr == RHS.Ptr;
+    return LHS.Ptr == RHS.Ptr;
   }
-  bool operator!=(const ConstIterator &RHS) const {
-    assert((!Ptr || isHandleInSync()) && "handle not in sync!");
-    assert((!RHS.Ptr || RHS.isHandleInSync()) && "handle not in sync!");
-    assert(getEpochAddress() == RHS.getEpochAddress() &&
-           "comparing incomparable iterators!");
-    return Ptr != RHS.Ptr;
+
+  friend bool operator!=(const DenseMapIterator &LHS,
+                         const DenseMapIterator &RHS) {
+    return !(LHS == RHS);
   }
 
   inline DenseMapIterator& operator++() {  // Preincrement
     assert(isHandleInSync() && "invalid iterator access!");
     assert(Ptr != End && "incrementing end() iterator");
     if (shouldReverseIterate<KeyT>()) {
       --Ptr;
       RetreatPastEmptyBuckets();

llvm/include/llvm/ADT/DenseSet.h

public:
 
     ValueT &operator*() { return I->getFirst(); }
     const ValueT &operator*() const { return I->getFirst(); }
     ValueT *operator->() { return &I->getFirst(); }
     const ValueT *operator->() const { return &I->getFirst(); }
 
     Iterator& operator++() { ++I; return *this; }
     Iterator operator++(int) { auto T = *this; ++I; return T; }
-    bool operator==(const ConstIterator& X) const { return I == X.I; }
-    bool operator!=(const ConstIterator& X) const { return I != X.I; }
+    friend bool operator==(const Iterator &X, const Iterator &Y) {
+      return X.I == Y.I;
+    }
+    friend bool operator!=(const Iterator &X, const Iterator &Y) {
+      return X.I != Y.I;
+    }
   };
 
   class ConstIterator {
     typename MapTy::const_iterator I;
     friend class DenseSetImpl;
     friend class Iterator;
 
   public:
     using difference_type = typename MapTy::const_iterator::difference_type;
     using value_type = ValueT;
     using pointer = const value_type *;
     using reference = const value_type &;
     using iterator_category = std::forward_iterator_tag;
 
     ConstIterator() = default;
     ConstIterator(const Iterator &B) : I(B.I) {}
     ConstIterator(const typename MapTy::const_iterator &i) : I(i) {}
 
     const ValueT &operator*() const { return I->getFirst(); }
     const ValueT *operator->() const { return &I->getFirst(); }
 
     ConstIterator& operator++() { ++I; return *this; }
     ConstIterator operator++(int) { auto T = *this; ++I; return T; }
-    bool operator==(const ConstIterator& X) const { return I == X.I; }
-    bool operator!=(const ConstIterator& X) const { return I != X.I; }
+    friend bool operator==(const ConstIterator &X, const ConstIterator &Y) {
+      return X.I == Y.I;
+    }
+    friend bool operator!=(const ConstIterator &X, const ConstIterator &Y) {
+      return X.I != Y.I;
+    }
   };
 
   using iterator = Iterator;
   using const_iterator = ConstIterator;
 
   iterator begin() { return Iterator(TheMap.begin()); }
   iterator end() { return Iterator(TheMap.end()); }
 

llvm/include/llvm/ADT/DirectedGraph.h

public:
   explicit DGEdge(const DGEdge<NodeType, EdgeType> &E)
       : TargetNode(E.TargetNode) {}
   DGEdge<NodeType, EdgeType> &operator=(const DGEdge<NodeType, EdgeType> &E) {
     TargetNode = E.TargetNode;
     return *this;
   }
 
   /// Static polymorphism: delegate implementation (via isEqualTo) to the
   /// derived class.
-  bool operator==(const EdgeType &E) const { return getDerived().isEqualTo(E); }
-  bool operator!=(const EdgeType &E) const { return !operator==(E); }
+  bool operator==(const DGEdge &E) const {
+    return getDerived().isEqualTo(E.getDerived());
+  }
+  bool operator!=(const DGEdge &E) const { return !operator==(E); }
 
   /// Retrieve the target node this edge connects to.
   const NodeType &getTargetNode() const { return TargetNode; }
   NodeType &getTargetNode() {
     return const_cast<NodeType &>(
         static_cast<const DGEdge<NodeType, EdgeType> &>(*this).getTargetNode());
   }
 
public:
   }
   DGNode<NodeType, EdgeType> &operator=(const DGNode<NodeType, EdgeType> &&N) {
     Edges = std::move(N.Edges);
     return *this;
   }
 
   /// Static polymorphism: delegate implementation (via isEqualTo) to the
   /// derived class.
-  bool operator==(const NodeType &N) const { return getDerived().isEqualTo(N); }
-  bool operator!=(const NodeType &N) const { return !operator==(N); }
+  friend bool operator==(const NodeType &M, const NodeType &N) {
+    return M.isEqualTo(N);
+  }
+  friend bool operator!=(const NodeType &M, const NodeType &N) {
+    return !(M == N);
+  }
 
   const_iterator begin() const { return Edges.begin(); }
   const_iterator end() const { return Edges.end(); }
   iterator begin() { return Edges.begin(); }
   iterator end() { return Edges.end(); }
   const EdgeType &front() const { return *Edges.front(); }
   EdgeType &front() { return *Edges.front(); }
   const EdgeType &back() const { return *Edges.back(); }

llvm/include/llvm/ADT/STLExtras.h

#endif
   early_inc_iterator_impl &operator++() {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
     assert(IsEarlyIncremented && "Cannot increment before dereferencing!");
     IsEarlyIncremented = false;
 #endif
     return *this;
   }
 
-  using BaseT::operator==;
-  bool operator==(const early_inc_iterator_impl &RHS) const {
+  friend bool operator==(const early_inc_iterator_impl &LHS,
+                         const early_inc_iterator_impl &RHS) {
 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
-    assert(!IsEarlyIncremented && "Cannot compare after dereferencing!");
+    assert(!LHS.IsEarlyIncremented && "Cannot compare after dereferencing!");
 #endif
-    return BaseT::operator==(RHS);
+    return (const BaseT &)LHS == (const BaseT &)RHS;
   }
 };
 
 /// Make a range that does early increment to allow mutation of the underlying
 /// range without disrupting iteration.
 ///
 /// The underlying iterator will be incremented immediately after it is
 /// dereferenced, allowing deletion of the current node or insertion of nodes to

llvm/include/llvm/ADT/StringMap.h

if (!NoAdvance)
       AdvancePastEmptyBuckets();
   }
 
   DerivedTy &operator=(const DerivedTy &Other) {
     Ptr = Other.Ptr;
     return static_cast<DerivedTy &>(*this);
   }
 
-  bool operator==(const DerivedTy &RHS) const { return Ptr == RHS.Ptr; }
+  friend bool operator==(const DerivedTy &LHS, const DerivedTy &RHS) {
+    return LHS.Ptr == RHS.Ptr;
+  }
 
   DerivedTy &operator++() { // Preincrement
     ++Ptr;
     AdvancePastEmptyBuckets();
     return static_cast<DerivedTy &>(*this);
   }
 
   DerivedTy operator++(int) { // Post-increment

llvm/include/llvm/ADT/iterator.h

DerivedT operator--(int) {
     static_assert(
         IsBidirectional,
         "The decrement operator is only defined for bidirectional iterators.");
     DerivedT tmp = *static_cast<DerivedT *>(this);
     --*static_cast<DerivedT *>(this);
     return tmp;
   }
 
-  bool operator!=(const DerivedT &RHS) const {
-    return !static_cast<const DerivedT *>(this)->operator==(RHS);
-  }
-
   bool operator>(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator<(RHS) &&
-           !static_cast<const DerivedT *>(this)->operator==(RHS);
+    return !(static_cast<const DerivedT &>(*this) < RHS) &&
+           !(static_cast<const DerivedT &>(*this) == RHS);
   }
   bool operator<=(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator>(RHS);
+    return !(static_cast<const DerivedT &>(*this) > RHS);
   }
   bool operator>=(const DerivedT &RHS) const {
     static_assert(
         IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return !static_cast<const DerivedT *>(this)->operator<(RHS);
+    return !(static_cast<const DerivedT &>(*this) < RHS);
   }
 
   PointerT operator->() { return &static_cast<DerivedT *>(this)->operator*(); }
   PointerT operator->() const {
     return &static_cast<const DerivedT *>(this)->operator*();
   }
   ReferenceProxy operator[](DifferenceTypeT n) {
     static_assert(IsRandomAccess,
public:
   DerivedT &operator--() {
     static_assert(
         BaseT::IsBidirectional,
         "The decrement operator is only defined for bidirectional iterators.");
     --I;
     return *static_cast<DerivedT *>(this);
   }
 
-  bool operator==(const DerivedT &RHS) const { return I == RHS.I; }
-  bool operator<(const DerivedT &RHS) const {
+  friend bool operator==(const iterator_adaptor_base &LHS,
+                         const iterator_adaptor_base &RHS) {
+    return LHS.I == RHS.I;
+  }
+  friend bool operator!=(const iterator_adaptor_base &LHS,
+                         const iterator_adaptor_base &RHS) {
+    return !(LHS == RHS);
+  }
+  friend bool operator<(const iterator_adaptor_base &LHS,
+                        const iterator_adaptor_base &RHS) {
     static_assert(
         BaseT::IsRandomAccess,
         "Relational operators are only defined for random access iterators.");
-    return I < RHS.I;
+    return LHS.I < RHS.I;
   }
 
   ReferenceT operator*() const { return *I; }
 };
 
 /// An iterator type that allows iterating over the pointees via some
 /// other iterator.
 ///

llvm/include/llvm/CodeGen/LiveInterval.h

public:
         P = P->Next;
         return *this;
       }
       SingleLinkedListIterator<T> operator++(int) {
         SingleLinkedListIterator res = *this;
         ++*this;
         return res;
       }
-      bool operator!=(const SingleLinkedListIterator<T> &Other) {
+      bool operator!=(const SingleLinkedListIterator<T> &Other) const {
         return P != Other.operator->();
       }
-      bool operator==(const SingleLinkedListIterator<T> &Other) {
+      bool operator==(const SingleLinkedListIterator<T> &Other) const {
         return P == Other.operator->();
       }
       T &operator*() const {
         return *P;
       }
       T *operator->() const {
         return P;
       }

llvm/include/llvm/IR/Attributes.h

public:
   td_range td_attrs() { return td_range(td_begin(), td_end()); }
 
   td_const_range td_attrs() const {
     return td_const_range(td_begin(), td_end());
   }
 
   bool td_empty() const { return TargetDepAttrs.empty(); }
 
-  bool operator==(const AttrBuilder &B);
-  bool operator!=(const AttrBuilder &B) {
-    return !(*this == B);
-  }
+  bool operator==(const AttrBuilder &B) const;
+  bool operator!=(const AttrBuilder &B) const { return !(*this == B); }
 };
 
 namespace AttributeFuncs {
 
 /// Which attributes cannot be applied to a type.
 AttrBuilder typeIncompatible(Type *Ty);
 
 /// \returns Return true if the two functions have compatible target-independent

llvm/include/llvm/IR/BasicBlock.h

class phi_iterator_impl
     phi_iterator_impl(PHINodeT *PN) : PN(PN) {}
 
   public:
     // Allow default construction to build variables, but this doesn't build
     // a useful iterator.
     phi_iterator_impl() = default;
 
     // Allow conversion between instantiations where valid.
-    template <typename PHINodeU, typename BBIteratorU>
+    template <typename PHINodeU, typename BBIteratorU,
+              typename = std::enable_if_t<
+                  std::is_convertible<PHINodeU *, PHINodeT *>::value>>
     phi_iterator_impl(const phi_iterator_impl<PHINodeU, BBIteratorU> &Arg)
         : PN(Arg.PN) {}
 
     bool operator==(const phi_iterator_impl &Arg) const { return PN == Arg.PN; }
 
     PHINodeT &operator*() const { return *PN; }
 
     using phi_iterator_impl::iterator_facade_base::operator++;

llvm/include/llvm/Object/StackMapParser.h

public:
 
     AccessorIterator& operator++() { A = A.next(); return *this; }
     AccessorIterator operator++(int) {
       auto tmp = *this;
       ++*this;
       return tmp;
     }
 
-    bool operator==(const AccessorIterator &Other) {
+    bool operator==(const AccessorIterator &Other) const {
       return A.P == Other.A.P;
     }
 
-    bool operator!=(const AccessorIterator &Other) { return !(*this == Other); }
+    bool operator!=(const AccessorIterator &Other) const {
+      return !(*this == Other);
+    }
 
     AccessorT& operator*() { return A; }
     AccessorT* operator->() { return &A; }
 
   private:
     AccessorT A;
   };
 

llvm/include/llvm/ProfileData/Coverage/CoverageMappingReader.h

~CoverageMappingIterator() {
     if (ReadErr != coveragemap_error::success)
       llvm_unreachable("Unexpected error in coverage mapping iterator");
   }
 
   CoverageMappingIterator &operator++() {
     increment();
     return *this;
   }
-  bool operator==(const CoverageMappingIterator &RHS) {
+  bool operator==(const CoverageMappingIterator &RHS) const {
     return Reader == RHS.Reader;
   }
-  bool operator!=(const CoverageMappingIterator &RHS) {
+  bool operator!=(const CoverageMappingIterator &RHS) const {
     return Reader != RHS.Reader;
   }
   Expected<CoverageMappingRecord &> operator*() {
     if (ReadErr != coveragemap_error::success) {
       auto E = make_error<CoverageMapError>(ReadErr);
       ReadErr = coveragemap_error::success;
       return std::move(E);
     }

llvm/include/llvm/ProfileData/InstrProfReader.h

class InstrProfIterator : public std::iterator<std::input_iterator_tag,
 
   void Increment();
 
 public:
   InstrProfIterator() = default;
   InstrProfIterator(InstrProfReader *Reader) : Reader(Reader) { Increment(); }
 
   InstrProfIterator &operator++() { Increment(); return *this; }
-  bool operator==(const InstrProfIterator &RHS) { return Reader == RHS.Reader; }
-  bool operator!=(const InstrProfIterator &RHS) { return Reader != RHS.Reader; }
+  bool operator==(const InstrProfIterator &RHS) const {
+    return Reader == RHS.Reader;
+  }
+  bool operator!=(const InstrProfIterator &RHS) const {
+    return Reader != RHS.Reader;
+  }
   value_type &operator*() { return Record; }
   value_type *operator->() { return &Record; }
 };
 
 /// Base class and interface for reading profiling data of any known instrprof
 /// format. Provides an iterator over NamedInstrProfRecords.
 class InstrProfReader {
   instrprof_error LastError = instrprof_error::success;

llvm/include/llvm/Support/BinaryStreamRef.h

public:
   /// Return a new BinaryStreamRef with the first \p Offset elements removed,
   /// and retaining exactly \p Len elements.
   RefType slice(uint32_t Offset, uint32_t Len) const {
     return drop_front(Offset).keep_front(Len);
   }
 
   bool valid() const { return BorrowedImpl != nullptr; }
 
-  bool operator==(const RefType &Other) const {
-    if (BorrowedImpl != Other.BorrowedImpl)
+  friend bool operator==(const RefType &Self, const RefType &Other) {
+    if (Self.BorrowedImpl != Other.BorrowedImpl)
       return false;
-    if (ViewOffset != Other.ViewOffset)
+    if (Self.ViewOffset != Other.ViewOffset)
       return false;
-    if (Length != Other.Length)
+    if (Self.Length != Other.Length)
       return false;
     return true;
   }
 
 protected:
   Error checkOffsetForRead(uint32_t Offset, uint32_t DataSize) const {
     if (Offset > getLength())
       return make_error<BinaryStreamError>(stream_error_code::invalid_offset);

llvm/lib/CodeGen/MachineOutliner.cpp

public:
     }
 
     RepeatedSubstringIterator operator++(int I) {
       RepeatedSubstringIterator It(*this);
       advance();
       return It;
     }
 
-    bool operator==(const RepeatedSubstringIterator &Other) {
+    bool operator==(const RepeatedSubstringIterator &Other) const {
       return N == Other.N;
     }
-    bool operator!=(const RepeatedSubstringIterator &Other) {
+    bool operator!=(const RepeatedSubstringIterator &Other) const {
       return !(*this == Other);
     }
 
     RepeatedSubstringIterator(SuffixTreeNode *N) : N(N) {
       // Do we have a non-null node?
       if (N) {
         // Yes. At the first step, we need to visit all of N's children.
         // Note: This means that we visit N last.

llvm/lib/CodeGen/PeepholeOptimizer.cpp

unsigned getSrcReg(int Idx) const {
       return RegSrcs[Idx].Reg;
     }
 
     unsigned getSrcSubReg(int Idx) const {
       assert(Idx < getNumSources() && "SubReg source out of index");
       return RegSrcs[Idx].SubReg;
     }
 
-    bool operator==(const ValueTrackerResult &Other) {
+    bool operator==(const ValueTrackerResult &Other) const {
       if (Other.getInst() != getInst())
         return false;
 
       if (Other.getNumSources() != getNumSources())
         return false;
 
       for (int i = 0, e = Other.getNumSources(); i != e; ++i)
         if (Other.getSrcReg(i) != getSrcReg(i) ||

llvm/lib/IR/Attributes.cpp

bool AttrBuilder::hasAttributes(AttributeList AL, uint64_t Index) const {
 
   return false;
 }
 
 bool AttrBuilder::hasAlignmentAttr() const {
   return Alignment != 0;
 }
 
-bool AttrBuilder::operator==(const AttrBuilder &B) {
+bool AttrBuilder::operator==(const AttrBuilder &B) const {
   if (Attrs != B.Attrs)
     return false;
 
   for (td_const_iterator I = TargetDepAttrs.begin(),
          E = TargetDepAttrs.end(); I != E; ++I)
     if (B.TargetDepAttrs.find(I->first) == B.TargetDepAttrs.end())
       return false;
 

llvm/lib/IR/DebugInfo.cpp

for (auto &BB : F) {
 
         // Remap DILocations in untyped MDNodes (e.g., llvm.loop).
         SmallVector<std::pair<unsigned, MDNode *>, 2> MDs;
         I.getAllMetadata(MDs);
         for (auto Attachment : MDs)
           if (auto *T = dyn_cast_or_null<MDTuple>(Attachment.second))
             for (unsigned N = 0; N < T->getNumOperands(); ++N)
               if (auto *Loc = dyn_cast_or_null<DILocation>(T->getOperand(N)))
-                if (Loc != DebugLoc())
+                if (Loc != DebugLoc().get())
                   T->replaceOperandWith(N, remapDebugLoc(Loc));
       }
     }
   }
 
   // Create a new llvm.dbg.cu, which is equivalent to the one
   // -gline-tables-only would have created.
   for (auto &NMD : M.getNamedMDList()) {

llvm/lib/Transforms/Scalar/GVNHoist.cpp

struct CHIArg {
   VNType VN;
 
   // Edge destination (shows the direction of flow), may not be where the I is.
   BasicBlock *Dest;
 
   // The instruction (VN) which uses the values flowing out of CHI.
   Instruction *I;
 
-  bool operator==(const CHIArg &A) { return VN == A.VN; }
-  bool operator!=(const CHIArg &A) { return !(*this == A); }
+  bool operator==(const CHIArg &A) const { return VN == A.VN; }
+  bool operator!=(const CHIArg &A) const { return !(*this == A); }
 };
 
 using CHIIt = SmallVectorImpl<CHIArg>::iterator;
 using CHIArgs = iterator_range<CHIIt>;
 using OutValuesType = DenseMap<BasicBlock *, SmallVector<CHIArg, 2>>;
 using InValuesType =
     DenseMap<BasicBlock *, SmallVector<std::pair<VNType, Instruction *>, 2>>;
 

llvm/unittests/ADT/STLExtrasTest.cpp

TEST(STLExtrasTest, splat) {
   EXPECT_FALSE(is_splat(V));
 }
 
 TEST(STLExtrasTest, to_address) {
   int *V1 = new int;
   EXPECT_EQ(V1, to_address(V1));
 
   // Check fancy pointer overload for unique_ptr
   std::unique_ptr<int> V2 = std::make_unique<int>(0);
-  EXPECT_EQ(V2.get(), to_address(V2));
+  EXPECT_EQ(V2.get(), (to_address)(V2));
 
   V2.reset(V1);
-  EXPECT_EQ(V1, to_address(V2));
+  EXPECT_EQ(V1, (to_address)(V2));
   V2.release();
 
   // Check fancy pointer overload for shared_ptr
   std::shared_ptr<int> V3 = std::make_shared<int>(0);
   std::shared_ptr<int> V4 = V3;
   EXPECT_EQ(V3.get(), V4.get());
-  EXPECT_EQ(V3.get(), to_address(V3));
-  EXPECT_EQ(V4.get(), to_address(V4));
+  EXPECT_EQ(V3.get(), (to_address)(V3));
+  EXPECT_EQ(V4.get(), (to_address)(V4));
 
   V3.reset(V1);
-  EXPECT_EQ(V1, to_address(V3));
+  EXPECT_EQ(V1, (to_address)(V3));
 }
 
 TEST(STLExtrasTest, partition_point) {
   std::vector<int> V = {1, 3, 5, 7, 9};
 
   // Range version.
   EXPECT_EQ(V.begin() + 3,
             partition_point(V, [](unsigned X) { return X < 7; }));
   EXPECT_EQ(V.begin(), partition_point(V, [](unsigned X) { return X < 1; }));
   EXPECT_EQ(V.end(), partition_point(V, [](unsigned X) { return X < 50; }));
 }
 
 } // namespace

llvm/unittests/Support/DJBTest.cpp

TEST(DJBTest, caseFolding) {
   };
 
   static constexpr TestCase Tests[] = {
       {{"ASDF"}, {"asdf"}},
       {{"qWeR"}, {"QwEr"}},
       {{"qqqqqqqqqqqqqqqqqqqq"}, {"QQQQQQQQQQQQQQQQQQQQ"}},
 
       {{"I"}, {"i"}},
+#ifndef __cpp_char8_t
       // Latin Small Letter Dotless I
       {{u8"\u0130"}, {"i"}},
       // Latin Capital Letter I With Dot Above
       {{u8"\u0131"}, {"i"}},
 
       // Latin Capital Letter A With Grave
       {{u8"\u00c0"}, {u8"\u00e0"}},
       // Latin Capital Letter A With Macron
       {{u8"\u0100"}, {u8"\u0101"}},
       // Latin Capital Letter L With Acute
       {{u8"\u0139"}, {u8"\u013a"}},
       // Cyrillic Capital Letter Ie
       {{u8"\u0415"}, {u8"\u0435"}},
       // Latin Capital Letter A With Circumflex And Grave
       {{u8"\u1ea6"}, {u8"\u1ea7"}},
       // Kelvin Sign
       {{u8"\u212a"}, {u8"\u006b"}},
       // Glagolitic Capital Letter Chrivi
       {{u8"\u2c1d"}, {u8"\u2c4d"}},
       // Fullwidth Latin Capital Letter M
       {{u8"\uff2d"}, {u8"\uff4d"}},
       // Old Hungarian Capital Letter Ej
       {{u8"\U00010c92"}, {u8"\U00010cd2"}},
+#endif
   };
 
   for (const TestCase &T : Tests) {
     SCOPED_TRACE("Comparing '" + T.One + "' and '" + T.Two + "'");
     EXPECT_EQ(caseFoldingDjbHash(T.One), caseFoldingDjbHash(T.Two));
   }
 }
 
TEST(DJBTest, knownValuesLowerCase) {
   for (const TestCase &T : Tests) {
     SCOPED_TRACE("Text: '" + T.Text + "'");
     EXPECT_EQ(T.Hash, djbHash(T.Text));
     EXPECT_EQ(T.Hash, caseFoldingDjbHash(T.Text));
     EXPECT_EQ(T.Hash, caseFoldingDjbHash(T.Text.upper()));
   }
 }
 
+#ifndef __cpp_char8_t
 TEST(DJBTest, knownValuesUnicode) {
   EXPECT_EQ(5866553u, djbHash(u8"\u0130"));
   EXPECT_EQ(177678u, caseFoldingDjbHash(u8"\u0130"));
   EXPECT_EQ(
       1302161417u,
       djbHash(
           u8"\u0130\u0131\u00c0\u00e0\u0100\u0101\u0139\u013a\u0415\u0435\u1ea6"
           u8"\u1ea7\u212a\u006b\u2c1d\u2c4d\uff2d\uff4d\U00010c92\U00010cd2"));
   EXPECT_EQ(
       1145571043u,
       caseFoldingDjbHash(
           u8"\u0130\u0131\u00c0\u00e0\u0100\u0101\u0139\u013a\u0415\u0435\u1ea6"
           u8"\u1ea7\u212a\u006b\u2c1d\u2c4d\uff2d\uff4d\U00010c92\U00010cd2"));
 }
+#endif
 No newline at end of file

llvm/unittests/Support/JSONTest.cpp

TEST(JSONTest, Parse) {
   Compare(R"(2.5)", 2.5);
   Compare(R"(2e50)", 2e50);
   Compare(R"(1.2e3456789)", std::numeric_limits<double>::infinity());
 
   Compare(R"("foo")", "foo");
   Compare(R"("\"\\\b\f\n\r\t")", "\"\\\b\f\n\r\t");
   Compare(R"("\u0000")", llvm::StringRef("\0", 1));
   Compare("\"\x7f\"", "\x7f");
+#ifndef __cpp_char8_t
   Compare(R"("\ud801\udc37")", u8"\U00010437"); // UTF16 surrogate pair escape.
   Compare("\"\xE2\x82\xAC\xF0\x9D\x84\x9E\"", 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.
+#endif
 
   Compare(R"({"":0,"":0})", Object{{"", 0}});
   Compare(R"({"obj":{},"arr":[]})", Object{{"obj", Object{}}, {"arr", {}}});
   Compare(R"({"\n":{"\u0000":[[[[]]]]}})",
           Object{{"\n", Object{
                             {llvm::StringRef("\0", 1), {{{{}}}}},
                         }}});
   Compare("\r[\n\t] ", {});