Consider reference, pointer, and pointer-to-membber TemplateArguments to be different if they have different types.

[rsmith]

Summary

For the Itanium ABI, this implements the mangling rule suggested in
https://github.com/itanium-cxx-abi/cxx-abi/issues/47, namely mangling
such template arguments as being cast to the parameter type in the case
where the template name is overloadable. This can cause a mangling
change for rare cases, where

• the template argument declaration is converted from its declared type to the type of the template parameter, and
• the template parameter either has a deduced type, is a parameter of a function template.

However, such changes are necessary to avoid mangling collisions. The
ABI changes can be reversed with -fclang-abi-compat=11 or earlier.

[• Quuxplusone]

clang/lib/AST/ItaniumMangle.cpp

4849

And from the PR summary:

namely mangling such template arguments as being cast to the parameter type in the case where the template name is unresolved or overloaded

This phrasing worries me a little bit. Are you saying that you might mangle the name of foo<SomeT> in one way, when there's also a foo<Some, Other, Args> in scope, and in a different way, when there's not? That doesn't seem conforming. So I imagine it's more likely that I'm misunderstanding what you mean by "might be overloaded" / "is overloaded". Could you explain for my information, and perhaps also adjust the wording of these code comments to make the explanation less needed?

Specifically, I think it would be non-conforming if the TU

// https://godbolt.org/z/YjPqMd
template<char *> void foo();
char arr[6];
extern template void foo<arr>();  // #1
int main() { foo<arr>(); }

could not be linked against the TU

template<int> int foo();
template<char *> void foo();  // is this "overloading"?
extern char arr[6];
template<> void foo<arr>() {}  // #2

because lines #1 and #2 disagreed about the way to mangle foo<arr>. (Again, I'm pretty sure you haven't made them disagree... but I remain unclear on what's meant by "overloading" in this PR, if it's not this.)

[rsmith]

Improve commit message.

[rsmith]

Tweak wording of comment.

clang/lib/AST/ItaniumMangle.cpp

4849

Well, technically, a single function template is considered overloaded all by itself :) ... but no, this is a typo in the change description. I meant "overloadable", not "overloaded". The proposed Itanium ABI rule applies to function templates (other than the call operator or conversion function of a generic lambda).

The "might be overloaded" here means "might be overloaded by some other (earlier or later or in a different TU) declaration", so I don't think that's wrong, but I'll rephrase it for the avoidance of any doubt.

(In principle the ABI rule also applies to cases where the template-name is unresolved, but it only makes a difference if the type of the template parameter is known and the template argument is not (eg, if it's the argument of a template template parameter). I suspect that's actually impossible, because the expression or type would need to be instantiation-dependent in that case, so we'd mangle the original syntax for the template argument not the result of converting it to the parameter type.)

[rsmith]

Rebase.

[rjmccall]

clang/lib/AST/ItaniumMangle.cpp

3758

Passing a null TemplateName here causes these to get the unresolved treatment, which means mangling the exact type, right? I guess it just never matters for integer arguments?

4847

This comment should probably say explicitly that I is the parameter index. Do we need to worry about packs that haven't yet been packed? Is it true that if we have a resolved template then we should always have packed the matching arguments?

4987

Could you /*comment*/ the false here?

[rsmith]

• Handle @rjmccall's review feedback.
• Properly handle the case of a pack expansion into a non-pack and add tests for that.

[rsmith]

clang/lib/AST/ItaniumMangle.cpp

3758

Yes, it never matters for expressions (this function), nor for evaluated integer constants (the previous function).

4847

Parameter renamed to ParamIdx.

Regarding packs, yes, that was my expectation (and it holds for all current examples in Clang's test suite), but it doesn't appear to be true in full generality. Here's a counterexample:

template<int A, int ...B> struct X {};

// Everyone agrees that the template arguments here are I (D) J (C...) E E
template<int D, int ...C> void h(X<D, C...>) {}
void i() { h<1, 2, 3, 4>(X<1, 2, 3, 4>()); }

// But everyone agrees that the template arguments here are I (C...) (D) E, with no J...E in sight
template<int D, int ...C> void f(X<C..., D>) {}
void g() { f<4, 1, 2, 3>(X<1, 2, 3, 4>()); }

I think the above example demonstrates a pre-existing hole in the ABI rule, which I would imagine we fix by following the implementations: if a left-to-right traversal of the parameters and arguments results in a pack expansion corresponding to a non-pack, then from that point onwards we don't form any J...E manglings and template arguments in an unresolved form (in particular, mangle non-type arguments as expressions).

I've added a test for that case. We don't strictly need to do anything special here to handle that, because it doesn't matter what needExactType returns when mangling an unresolved template argument, but it seems better to more precisely track whether we expect to see matching arguments and parameters or not, so we now track that here too.

Thanks for catching this!

[rjmccall]

Seems fine to me.

clang/lib/AST/ItaniumMangle.cpp

4847

Ugh. I think the right rule in the abstract would be to always mangle template arguments in a dependent template argument list using their written structure, even when we can immediately resolve the target template and check arguments against parameters. That would certainly include not trying to collect arguments into template parameter packs. But that ship probably sailed a long time ago, and your left-to-right rule is presumably what we're left with. We should document that in the ABI, though; mind opening a PR?

[rsmith]

clang/lib/AST/ItaniumMangle.cpp

4847

Not sure if PR in this context is problem report or pull request, but: https://github.com/itanium-cxx-abi/cxx-abi/issues/113

[mehdi_amini]

Clang is crashing after this change when bootstrapping and building lib/Support/CMakeFiles/LLVMSupport.dir/Hashing.cpp.o
(our log if it helps: https://buildkite.com/mlir/mlir-core/builds/10003#80a5b6a9-d8d9-4420-ab2a-c24f398bc5d4 )

[nikic]

This also crashes test-suite, so I've reverted the change for now. (Stack trace for tramp3d-v4 crash: https://llvm-compile-time-tracker.com/show_error.php?commit=7b3470baf8bab1919e3ad4c18e2b776c1f7be2d5)

[davezarzycki]

This change is causing second stage build failures on Fedora 33 (x86-64). I'll probably revert this soon, but in the mean time, here is a snippet of the build output:

FAILED: lib/ExecutionEngine/JITLink/CMakeFiles/LLVMJITLink.dir/JITLinkGeneric.cpp.o
/p/tllvm/bin/clang++ -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Ilib/ExecutionEngine/JITLink -I/home/dave/ro_s/lp/llvm/lib/ExecutionEngine/JITLink -Iinclude -I/home/dave/ro_s/lp/llvm/include -Werror=switch -Wno-deprecated-copy -stdlib=libc++ -fPIC -fvisibility-inlines-hidden -Werror=date-time -Werror=unguarded-availability-new -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wmissing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wcovered-switch-default -Wno-noexcept-type -Wnon-virtual-dtor -Wdelete-non-virtual-dtor -Wsuggest-override -Wstring-conversion -fdiagnostics-color -ffunction-sections -fdata-sections -O2   -march=skylake -fno-vectorize -fno-slp-vectorize -fno-tree-slp-vectorize -fno-exceptions -fno-rtti -UNDEBUG -std=c++14 -MD -MT lib/ExecutionEngine/JITLink/CMakeFiles/LLVMJITLink.dir/JITLinkGeneric.cpp.o -MF lib/ExecutionEngine/JITLink/CMakeFiles/LLVMJITLink.dir/JITLinkGeneric.cpp.o.d -o lib/ExecutionEngine/JITLink/CMakeFiles/LLVMJITLink.dir/JITLinkGeneric.cpp.o -c /home/dave/ro_s/lp/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp
In file included from /home/dave/ro_s/lp/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp:13:
/home/dave/ro_s/lp/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.h:150:18: error: invalid operands to binary expression ('llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' and 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>')
    for (auto *B : G.blocks()) {
                 ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/APInt.h:2037:13: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'uint64_t' (aka 'unsigned long') for 1st argument
inline bool operator!=(uint64_t V1, const APInt &V2) { return V2 != V1; }
            ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/APSInt.h:340:13: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'int64_t' (aka 'long') for 1st argument
inline bool operator!=(int64_t V1, const APSInt &V2) { return V2 != V1; }
            ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/StringRef.h:904:15: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'llvm::StringRef' for 1st argument
  inline bool operator!=(StringRef LHS, StringRef RHS) { return !(LHS == RHS); }
              ^
/p/tllvm/bin/../include/c++/v1/system_error:419:1: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'const std::error_code' for 1st argument
operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/system_error:424:1: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'const std::error_code' for 1st argument
operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/system_error:429:1: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'const std::error_condition' for 1st argument
operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/system_error:434:1: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'const std::error_condition' for 1st argument
operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
^
/home/dave/ro_s/lp/llvm/include/llvm/Support/Alignment.h:262:13: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'llvm::Align' for 1st argument
inline bool operator!=(Align Lhs, uint64_t Rhs) {
            ^
/home/dave/ro_s/lp/llvm/include/llvm/Support/Alignment.h:287:13: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'llvm::MaybeAlign' for 1st argument
inline bool operator!=(MaybeAlign Lhs, uint64_t Rhs) {
            ^
/home/dave/ro_s/lp/llvm/include/llvm/Support/Alignment.h:295:13: note: candidate function not viable: no known conversion from 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>' to 'llvm::Align' for 1st argument
inline bool operator!=(Align Lhs, Align Rhs) {
            ^
/p/tllvm/bin/../include/c++/v1/utility:584:1: note: candidate template ignored: could not match 'pair' against 'nested_collection_iterator'
operator!=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)
^
/p/tllvm/bin/../include/c++/v1/iterator:818:1: note: candidate template ignored: could not match 'reverse_iterator' against 'nested_collection_iterator'
operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
^
/p/tllvm/bin/../include/c++/v1/iterator:1040:1: note: candidate template ignored: could not match 'istream_iterator' against 'nested_collection_iterator'
operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
^
/p/tllvm/bin/../include/c++/v1/iterator:1151:6: note: candidate template ignored: could not match 'istreambuf_iterator' against 'nested_collection_iterator'
bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
     ^
/p/tllvm/bin/../include/c++/v1/iterator:1274:1: note: candidate template ignored: could not match 'move_iterator' against 'nested_collection_iterator'
operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
^
/p/tllvm/bin/../include/c++/v1/iterator:1650:1: note: candidate template ignored: could not match '__wrap_iter' against 'nested_collection_iterator'
operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/iterator:1682:1: note: candidate template ignored: could not match '__wrap_iter' against 'nested_collection_iterator'
operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/tuple:1185:1: note: candidate template ignored: could not match 'tuple' against 'nested_collection_iterator'
operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
^
/p/tllvm/bin/../include/c++/v1/memory:1713:6: note: candidate template ignored: could not match 'allocator' against 'nested_collection_iterator'
bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
     ^
/p/tllvm/bin/../include/c++/v1/memory:2642:1: note: candidate template ignored: could not match 'unique_ptr' against 'nested_collection_iterator'
operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);}
^
/p/tllvm/bin/../include/c++/v1/memory:2689:1: note: candidate template ignored: could not match 'unique_ptr' against 'nested_collection_iterator'
operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/memory:2697:1: note: candidate template ignored: could not match 'unique_ptr' against 'nested_collection_iterator'
operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/memory:4082:1: note: candidate template ignored: could not match 'shared_ptr' against 'nested_collection_iterator'
operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/memory:4144:1: note: candidate template ignored: could not match 'shared_ptr' against 'nested_collection_iterator'
operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/memory:4152:1: note: candidate template ignored: could not match 'shared_ptr' against 'nested_collection_iterator'
operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
^
/p/tllvm/bin/../include/c++/v1/functional:2599:1: note: candidate template ignored: could not match 'function' against 'nested_collection_iterator'
operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
^
/p/tllvm/bin/../include/c++/v1/functional:2604:1: note: candidate template ignored: could not match 'function' against 'nested_collection_iterator'
operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
^
/p/tllvm/bin/../include/c++/v1/string_view:664:6: note: candidate template ignored: could not match 'basic_string_view' against 'nested_collection_iterator'
bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
     ^
/p/tllvm/bin/../include/c++/v1/string_view:673:6: note: candidate template ignored: could not match 'basic_string_view' against 'nested_collection_iterator'
bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
     ^
/p/tllvm/bin/../include/c++/v1/string_view:683:6: note: candidate template ignored: could not match 'basic_string_view' against 'nested_collection_iterator'
bool operator!=(typename common_type<basic_string_view<_CharT, _Traits> >::type __lhs,
     ^
/p/tllvm/bin/../include/c++/v1/string:571:6: note: candidate template ignored: could not match 'fpos' against 'nested_collection_iterator'
bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y)
     ^
/p/tllvm/bin/../include/c++/v1/string:4072:1: note: candidate template ignored: could not match 'basic_string' against 'nested_collection_iterator'
operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
^
/p/tllvm/bin/../include/c++/v1/string:4081:1: note: candidate template ignored: could not match 'const _CharT *' against 'llvm::jitlink::LinkGraph::nested_collection_iterator<llvm::pointee_iterator<std::__wrap_iter<const std::unique_ptr<llvm::jitlink::Section> *>, llvm::jitlink::Section>, llvm::detail::DenseSetImpl<llvm::jitlink::Block *, llvm::DenseMap<llvm::jitlink::Block *, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::jitlink::Block *>, llvm::detail::DenseSetPair<llvm::jitlink::Block *>>, llvm::DenseMapInfo<llvm::jitlink::Block *>>::Iterator, llvm::jitlink::Block *, &llvm::jitlink::LinkGraph::getSectionBlocks>'
operator!=(const _CharT* __lhs,
^
/p/tllvm/bin/../include/c++/v1/string:4090:1: note: candidate template ignored: could not match 'basic_string' against 'nested_collection_iterator'
operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/Optional.h:315:16: note: candidate template ignored: could not match 'Optional' against 'nested_collection_iterator'
constexpr bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
               ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/Optional.h:352:16: note: candidate template ignored: could not match 'Optional' against 'nested_collection_iterator'
constexpr bool operator!=(const Optional<T> &X, NoneType) {
               ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/Optional.h:357:16: note: candidate template ignored: could not match 'Optional' against 'nested_collection_iterator'
constexpr bool operator!=(NoneType, const Optional<T> &X) {
               ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/Optional.h:408:16: note: candidate template ignored: could not match 'Optional' against 'nested_collection_iterator'
constexpr bool operator!=(const Optional<T> &X, const T &Y) {
               ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/Optional.h:413:16: note: candidate template ignored: could not match 'Optional' against 'nested_collection_iterator'
constexpr bool operator!=(const T &X, const Optional<T> &Y) {
               ^
/p/tllvm/bin/../include/c++/v1/array:381:1: note: candidate template ignored: could not match 'array' against 'nested_collection_iterator'
operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
^
/p/tllvm/bin/../include/c++/v1/vector:3346:1: note: candidate template ignored: could not match 'vector' against 'nested_collection_iterator'
operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/ArrayRef.h:541:15: note: candidate template ignored: could not match 'ArrayRef' against 'nested_collection_iterator'
  inline bool operator!=(ArrayRef<T> LHS, ArrayRef<T> RHS) {
              ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/ArrayRef.h:546:15: note: candidate template ignored: could not match 'SmallVectorImpl' against 'nested_collection_iterator'
  inline bool operator!=(SmallVectorImpl<T> &LHS, ArrayRef<T> RHS) {
              ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/DenseMap.h:704:6: note: candidate template ignored: could not match 'DenseMapBase' against 'nested_collection_iterator'
bool operator!=(
     ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/DenseSet.h:251:6: note: candidate template ignored: could not match 'DenseSetImpl' against 'nested_collection_iterator'
bool operator!=(const DenseSetImpl<ValueT, MapTy, ValueInfoT> &LHS,
     ^
/p/tllvm/bin/../include/c++/v1/map:1614:1: note: candidate template ignored: could not match 'map' against 'nested_collection_iterator'
operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
^
/p/tllvm/bin/../include/c++/v1/map:2199:1: note: candidate template ignored: could not match 'multimap' against 'nested_collection_iterator'
operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
^
/p/tllvm/bin/../include/c++/v1/set:918:1: note: candidate template ignored: could not match 'set' against 'nested_collection_iterator'
operator!=(const set<_Key, _Compare, _Allocator>& __x,
^
/p/tllvm/bin/../include/c++/v1/set:1445:1: note: candidate template ignored: could not match 'multiset' against 'nested_collection_iterator'
operator!=(const multiset<_Key, _Compare, _Allocator>& __x,
^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/PointerUnion.h:241:6: note: candidate template ignored: could not match 'PointerUnion' against 'nested_collection_iterator'
bool operator!=(PointerUnion<PTs...> lhs, PointerUnion<PTs...> rhs) {
     ^
/home/dave/ro_s/lp/llvm/include/llvm/ADT/iterator.h:145:8: note: candidate function not viable: no known conversion from 'nested_collection_iterator<...>' to 'const nested_collection_iterator<...>' for 1st argument
  bool operator!=(const DerivedT &RHS) const {
       ^

[teemperor]

I believe rsmith is in GMT-8, so I assume this won't get a fix soon and I went ahead and reverted in 22ccdb787024e954318e35fcf904fd4fa36f5679

[davezarzycki]

Thanks. I just verified that reverting this change fixes the second stage regression and was about to commit the revert.

@rsmith – If you need help testing a fix, please let me know.

[rsmith]

In D91488#2451755, @teemperor wrote:

I believe rsmith is in GMT-8, so I assume this won't get a fix soon and I went ahead and reverted in 22ccdb787024e954318e35fcf904fd4fa36f5679

In D91488#2451760, @davezarzycki wrote:

Thanks. I just verified that reverting this change fixes the second stage regression and was about to commit the revert.

Thanks for the revert and verification. I saw these failures yesterday, but I incorrectly thought I saw the same failures in stage1, so they couldn't possibly be due to my change because they were compilation failures in LLVM. Oops!

clang/include/clang/Basic/LangOptions.h

enum class ClangABI {
     /// Attempt to be ABI-compatible with code generated by Clang 9.0.x
     /// (SVN r351319). This causes vectors of __int128 to be passed in memory
     /// instead of passing in multiple scalar registers on x86_64 on Linux and
     /// NetBSD.
     Ver9,
 
     /// Attempt to be ABI-compatible with code generated by Clang 11.0.x
     /// (git  2e10b7a39b93). This causes clang to pass unions with a 256-bit
-    /// vector member on the stack instead of using registers, and to not
-    /// properly mangle substitutions for template names in some cases.
+    /// vector member on the stack instead of using registers, to not properly
+    /// mangle substitutions for template names in some cases, and to mangle
+    /// declaration template arguments without a cast to the parameter type
+    /// even when that can lead to mangling collisions.
     Ver11,
 
     /// Conform to the underlying platform's C and C++ ABIs as closely
     /// as we can.
     Latest
   };
 
   enum class CoreFoundationABI {

clang/lib/AST/ItaniumMangle.cpp

void mangleMemberExpr(const Expr *base, bool isArrow,
                         unsigned knownArity);
   void mangleCastExpression(const Expr *E, StringRef CastEncoding);
   void mangleInitListElements(const InitListExpr *InitList);
   void mangleDeclRefExpr(const NamedDecl *D);
   void mangleExpression(const Expr *E, unsigned Arity = UnknownArity);
   void mangleCXXCtorType(CXXCtorType T, const CXXRecordDecl *InheritedFrom);
   void mangleCXXDtorType(CXXDtorType T);
 
-  void mangleTemplateArgs(const TemplateArgumentLoc *TemplateArgs,
+  void mangleTemplateArgs(TemplateName TN,
+                          const TemplateArgumentLoc *TemplateArgs,
                           unsigned NumTemplateArgs);
-  void mangleTemplateArgs(const TemplateArgument *TemplateArgs,
+  void mangleTemplateArgs(TemplateName TN, const TemplateArgument *TemplateArgs,
                           unsigned NumTemplateArgs);
-  void mangleTemplateArgs(const TemplateArgumentList &AL);
-  void mangleTemplateArg(TemplateArgument A);
-  void mangleValueInTemplateArg(QualType T, const APValue &V);
+  void mangleTemplateArgs(TemplateName TN, const TemplateArgumentList &AL);
+  void mangleTemplateArg(TemplateArgument A, bool NeedExactType);
+  void mangleValueInTemplateArg(QualType T, const APValue &V, bool TopLevel,
+                                bool NeedExactType = false);
 
   void mangleTemplateParameter(unsigned Depth, unsigned Index);
 
   void mangleFunctionParam(const ParmVarDecl *parm);
 
   void writeAbiTags(const NamedDecl *ND,
                     const AbiTagList *AdditionalAbiTags);
 
if (const VarTemplateSpecializationDecl *Spec =
           dyn_cast<VarTemplateSpecializationDecl>(ND)) {
     TemplateArgs = &Spec->getTemplateArgs();
     return GD.getWithDecl(Spec->getSpecializedTemplate());
   }
 
   return GlobalDecl();
 }
 
+static TemplateName asTemplateName(GlobalDecl GD) {
+  const TemplateDecl *TD = dyn_cast_or_null<TemplateDecl>(GD.getDecl());
+  return TemplateName(const_cast<TemplateDecl*>(TD));
+}
+
 void CXXNameMangler::mangleName(GlobalDecl GD) {
   const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
   if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
     // Variables should have implicit tags from its type.
     AbiTagList VariableTypeAbiTags = makeVariableTypeTags(VD);
     if (VariableTypeAbiTags.empty()) {
       // Simple case no variable type tags.
       mangleNameWithAbiTags(VD, nullptr);
if (!ND->hasExternalFormalLinkage())
     if (Module *M = ND->getOwningModuleForLinkage())
       mangleModuleName(M);
 
   if (DC->isTranslationUnit() || isStdNamespace(DC)) {
     // Check if we have a template.
     const TemplateArgumentList *TemplateArgs = nullptr;
     if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
       mangleUnscopedTemplateName(TD, AdditionalAbiTags);
-      mangleTemplateArgs(*TemplateArgs);
+      mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
       return;
     }
 
     mangleUnscopedName(GD, AdditionalAbiTags);
     return;
   }
 
   mangleNestedName(GD, DC, AdditionalAbiTags);

 
 void CXXNameMangler::mangleTemplateName(const TemplateDecl *TD,
                                         const TemplateArgument *TemplateArgs,
                                         unsigned NumTemplateArgs) {
   const DeclContext *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD));
 
   if (DC->isTranslationUnit() || isStdNamespace(DC)) {
     mangleUnscopedTemplateName(TD, nullptr);
-    mangleTemplateArgs(TemplateArgs, NumTemplateArgs);
+    mangleTemplateArgs(asTemplateName(TD), TemplateArgs, NumTemplateArgs);
   } else {
     mangleNestedName(TD, TemplateArgs, NumTemplateArgs);
   }
 }
 
 void CXXNameMangler::mangleUnscopedName(GlobalDecl GD,
                                         const AbiTagList *AdditionalAbiTags) {
   const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());

 void CXXNameMangler::manglePrefix(QualType type) {
   if (const auto *TST = type->getAs<TemplateSpecializationType>()) {
     if (!mangleSubstitution(QualType(TST, 0))) {
       mangleTemplatePrefix(TST->getTemplateName());
 
       // FIXME: GCC does not appear to mangle the template arguments when
       // the template in question is a dependent template name. Should we
       // emulate that badness?
-      mangleTemplateArgs(TST->getArgs(), TST->getNumArgs());
+      mangleTemplateArgs(TST->getTemplateName(), TST->getArgs(),
+                         TST->getNumArgs());
       addSubstitution(QualType(TST, 0));
     }
   } else if (const auto *DTST =
                  type->getAs<DependentTemplateSpecializationType>()) {
     if (!mangleSubstitution(QualType(DTST, 0))) {
       TemplateName Template = getASTContext().getDependentTemplateName(
           DTST->getQualifier(), DTST->getIdentifier());
       mangleTemplatePrefix(Template);
 
       // FIXME: GCC does not appear to mangle the template arguments when
       // the template in question is a dependent template name. Should we
       // emulate that badness?
-      mangleTemplateArgs(DTST->getArgs(), DTST->getNumArgs());
+      mangleTemplateArgs(Template, DTST->getArgs(), DTST->getNumArgs());
       addSubstitution(QualType(DTST, 0));
     }
   } else {
     // We use the QualType mangle type variant here because it handles
     // substitutions.
     mangleType(type);
   }
 }
switch (name.getNameKind()) {
     case DeclarationName::ObjCOneArgSelector:
     case DeclarationName::ObjCZeroArgSelector:
       llvm_unreachable("Can't mangle Objective-C selector names here!");
   }
 
   // The <simple-id> and on <operator-name> productions end in an optional
   // <template-args>.
   if (TemplateArgs)
-    mangleTemplateArgs(TemplateArgs, NumTemplateArgs);
+    mangleTemplateArgs(TemplateName(), TemplateArgs, NumTemplateArgs);
 }
 
 void CXXNameMangler::mangleUnqualifiedName(GlobalDecl GD,
                                            DeclarationName Name,
                                            unsigned KnownArity,
                                            const AbiTagList *AdditionalAbiTags) {
   const NamedDecl *ND = cast_or_null<NamedDecl>(GD.getDecl());
   unsigned Arity = KnownArity;
if (auto *GD = dyn_cast<MSGuidDecl>(ND)) {
       llvm::raw_svector_ostream GUIDOS(GUID);
       Context.mangleMSGuidDecl(GD, GUIDOS);
       Out << GUID.size() << GUID;
       break;
     }
 
     if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
       // Proposed in https://github.com/itanium-cxx-abi/cxx-abi/issues/63.
-      Out << "TAX";
+      Out << "TA";
       mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
-                               TPO->getValue());
-      Out << "E";
+                               TPO->getValue(), /*TopLevel=*/true);
       break;
     }
 
     if (II) {
       // Match GCC's naming convention for internal linkage symbols, for
       // symbols that are not actually visible outside of this TU. GCC
       // distinguishes between internal and external linkage symbols in
       // its mangling, to support cases like this that were valid C++ prior
void CXXNameMangler::mangleUnqualifiedName(GlobalDecl GD,
 
   case DeclarationName::ObjCZeroArgSelector:
   case DeclarationName::ObjCOneArgSelector:
   case DeclarationName::ObjCMultiArgSelector:
     llvm_unreachable("Can't mangle Objective-C selector names here!");
 
   case DeclarationName::CXXConstructorName: {
     const CXXRecordDecl *InheritedFrom = nullptr;
+    TemplateName InheritedTemplateName;
     const TemplateArgumentList *InheritedTemplateArgs = nullptr;
     if (auto Inherited =
             cast<CXXConstructorDecl>(ND)->getInheritedConstructor()) {
       InheritedFrom = Inherited.getConstructor()->getParent();
+      InheritedTemplateName =
+          TemplateName(Inherited.getConstructor()->getPrimaryTemplate());
       InheritedTemplateArgs =
           Inherited.getConstructor()->getTemplateSpecializationArgs();
     }
 
     if (ND == Structor)
       // If the named decl is the C++ constructor we're mangling, use the type
       // we were given.
       mangleCXXCtorType(static_cast<CXXCtorType>(StructorType), InheritedFrom);
     else
       // Otherwise, use the complete constructor name. This is relevant if a
       // class with a constructor is declared within a constructor.
       mangleCXXCtorType(Ctor_Complete, InheritedFrom);
 
     // FIXME: The template arguments are part of the enclosing prefix or
     // nested-name, but it's more convenient to mangle them here.
     if (InheritedTemplateArgs)
-      mangleTemplateArgs(*InheritedTemplateArgs);
+      mangleTemplateArgs(InheritedTemplateName, *InheritedTemplateArgs);
 
     writeAbiTags(ND, AdditionalAbiTags);
     break;
   }
 
   case DeclarationName::CXXDestructorName:
     if (ND == Structor)
       // If the named decl is the C++ destructor we're mangling, use the type we
if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
     mangleQualifiers(MethodQuals);
     mangleRefQualifier(Method->getRefQualifier());
   }
 
   // Check if we have a template.
   const TemplateArgumentList *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
     mangleTemplatePrefix(TD, NoFunction);
-    mangleTemplateArgs(*TemplateArgs);
+    mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
   }
   else {
     manglePrefix(DC, NoFunction);
     mangleUnqualifiedName(GD, AdditionalAbiTags);
   }
 
   Out << 'E';
 }
 void CXXNameMangler::mangleNestedName(const TemplateDecl *TD,
                                       const TemplateArgument *TemplateArgs,
                                       unsigned NumTemplateArgs) {
   // <nested-name> ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
 
   Out << 'N';
 
   mangleTemplatePrefix(TD);
-  mangleTemplateArgs(TemplateArgs, NumTemplateArgs);
+  mangleTemplateArgs(asTemplateName(TD), TemplateArgs, NumTemplateArgs);
 
   Out << 'E';
 }
 
 static GlobalDecl getParentOfLocalEntity(const DeclContext *DC) {
   GlobalDecl GD;
   // The Itanium spec says:
   // For entities in constructors and destructors, the mangling of the
if (Decl *Context = Lambda->getLambdaContextDecl()) {
     if ((isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
         !isa<ParmVarDecl>(Context)) {
       // FIXME: 'inline auto [a, b] = []{ return ... };' does not get a
       // reasonable mangling here.
       if (const IdentifierInfo *Name
             = cast<NamedDecl>(Context)->getIdentifier()) {
         mangleSourceName(Name);
         const TemplateArgumentList *TemplateArgs = nullptr;
-        if (isTemplate(cast<NamedDecl>(Context), TemplateArgs))
-          mangleTemplateArgs(*TemplateArgs);
+        if (GlobalDecl TD = isTemplate(cast<NamedDecl>(Context), TemplateArgs))
+          mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
         Out << 'M';
       }
     }
   }
 
   Out << "Ul";
   mangleLambdaSig(Lambda);
   Out << "E";
void CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) {
   const NamedDecl *ND = cast<NamedDecl>(DC);
   if (mangleSubstitution(ND))
     return;
 
   // Check if we have a template.
   const TemplateArgumentList *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(ND, TemplateArgs)) {
     mangleTemplatePrefix(TD);
-    mangleTemplateArgs(*TemplateArgs);
+    mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
   } else {
     manglePrefix(getEffectiveDeclContext(ND), NoFunction);
     mangleUnqualifiedName(ND, nullptr);
   }
 
   addSubstitution(ND);
 }
 
case TemplateName::SubstTemplateTemplateParmPack: {
       // template <template <class U> class T...> class A {
       //   template <class U...> void foo(decltype(T<U>::foo) x...);
       // };
       Out << "_SUBSTPACK_";
       break;
     }
     }
 
-    mangleTemplateArgs(TST->getArgs(), TST->getNumArgs());
+    mangleTemplateArgs(TN, TST->getArgs(), TST->getNumArgs());
     break;
   }
 
   case Type::InjectedClassName:
     mangleSourceNameWithAbiTags(
         cast<InjectedClassNameType>(Ty)->getDecl());
     break;
 
   case Type::DependentName:
     mangleSourceName(cast<DependentNameType>(Ty)->getIdentifier());
     break;
 
   case Type::DependentTemplateSpecialization: {
     const DependentTemplateSpecializationType *DTST =
         cast<DependentTemplateSpecializationType>(Ty);
+    TemplateName Template = getASTContext().getDependentTemplateName(
+        DTST->getQualifier(), DTST->getIdentifier());
     mangleSourceName(DTST->getIdentifier());
-    mangleTemplateArgs(DTST->getArgs(), DTST->getNumArgs());
+    mangleTemplateArgs(Template, DTST->getArgs(), DTST->getNumArgs());
     break;
   }
 
   case Type::Elaborated:
     return mangleUnresolvedTypeOrSimpleId(
         cast<ElaboratedType>(Ty)->getNamedType(), Prefix);
   }
 

 
 void CXXNameMangler::mangleType(const DependentSizedMatrixType *T) {
   // Mangle matrix types as a vendor extended type:
   // u<Len>matrix_typeI<row expr><column expr><element type>E
   StringRef VendorQualifier = "matrix_type";
   Out << "u" << VendorQualifier.size() << VendorQualifier;
 
   Out << "I";
-  mangleTemplateArg(T->getRowExpr());
-  mangleTemplateArg(T->getColumnExpr());
+  mangleTemplateArg(T->getRowExpr(), false);
+  mangleTemplateArg(T->getColumnExpr(), false);
   mangleType(T->getElementType());
   Out << "E";
 }
 
 void CXXNameMangler::mangleType(const DependentAddressSpaceType *T) {
   SplitQualType split = T->getPointeeType().split();
   mangleQualifiers(split.Quals, T);
   mangleType(QualType(split.Ty, 0));
if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) {
     if (mangleSubstitution(QualType(T, 0)))
       return;
 
     mangleTemplatePrefix(T->getTemplateName());
 
     // FIXME: GCC does not appear to mangle the template arguments when
     // the template in question is a dependent template name. Should we
     // emulate that badness?
-    mangleTemplateArgs(T->getArgs(), T->getNumArgs());
+    mangleTemplateArgs(T->getTemplateName(), T->getArgs(), T->getNumArgs());
     addSubstitution(QualType(T, 0));
   }
 }
 
 void CXXNameMangler::mangleType(const DependentNameType *T) {
   // Proposal by cxx-abi-dev, 2014-03-26
   // <class-enum-type> ::= <name>    # non-dependent or dependent type name or
   //                                 # dependent elaborated type specifier using
void CXXNameMangler::mangleType(const DependentTemplateSpecializationType *T) {
   TemplateName Prefix =
     getASTContext().getDependentTemplateName(T->getQualifier(),
                                              T->getIdentifier());
   mangleTemplatePrefix(Prefix);
 
   // FIXME: GCC does not appear to mangle the template arguments when
   // the template in question is a dependent template name. Should we
   // emulate that badness?
-  mangleTemplateArgs(T->getArgs(), T->getNumArgs());
+  mangleTemplateArgs(Prefix, T->getArgs(), T->getNumArgs());
   Out << 'E';
 }
 
 void CXXNameMangler::mangleType(const TypeOfType *T) {
   // FIXME: this is pretty unsatisfactory, but there isn't an obvious
   // "extension with parameters" mangling.
   Out << "u6typeof";
 }
void CXXNameMangler::mangleType(const PipeType *T) {
   Out << "8ocl_pipe";
 }
 
 void CXXNameMangler::mangleType(const ExtIntType *T) {
   Out << "U7_ExtInt";
   llvm::APSInt BW(32, true);
   BW = T->getNumBits();
   TemplateArgument TA(Context.getASTContext(), BW, getASTContext().IntTy);
-  mangleTemplateArgs(&TA, 1);
+  mangleTemplateArgs(TemplateName(), &TA, 1);
   if (T->isUnsigned())
     Out << "j";
   else
     Out << "i";
 }
 
 void CXXNameMangler::mangleType(const DependentExtIntType *T) {
   Out << "U7_ExtInt";
   TemplateArgument TA(T->getNumBitsExpr());
-  mangleTemplateArgs(&TA, 1);
+  mangleTemplateArgs(TemplateName(), &TA, 1);
   if (T->isUnsigned())
     Out << "j";
   else
     Out << "i";
 }
 
 void CXXNameMangler::mangleIntegerLiteral(QualType T,
                                           const llvm::APSInt &Value) {
case Expr::PackExpansionExprClass:
     mangleExpression(cast<PackExpansionExpr>(E)->getPattern());
     break;
 
   case Expr::SizeOfPackExprClass: {
     auto *SPE = cast<SizeOfPackExpr>(E);
     if (SPE->isPartiallySubstituted()) {
       Out << "sP";
       for (const auto &A : SPE->getPartialArguments())
-        mangleTemplateArg(A);
+        mangleTemplateArg(A, false);
       Out << "E";
       break;
     }
 
     Out << "sZ";
     const NamedDecl *Pack = SPE->getPack();
     if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Pack))
       mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
case Dtor_Base:
     Out << "D2";
     break;
   case Dtor_Comdat:
     Out << "D5";
     break;
   }
 }
 
-void CXXNameMangler::mangleTemplateArgs(const TemplateArgumentLoc *TemplateArgs,
+namespace {
+// Helper to provide ancillary information on a template used to mangle its
+// arguments.
+struct TemplateArgManglingInfo {
+  TemplateDecl *ResolvedTemplate = nullptr;
+  bool SeenPackExpansionIntoNonPack = false;
+
+  TemplateArgManglingInfo(TemplateName TN) {
+    if (TemplateDecl *TD = TN.getAsTemplateDecl())
+      ResolvedTemplate = TD;
+  }
+
+  /// Do we need to mangle template arguments with exactly correct types?
+  ///
+  /// This should be called exactly once for each parameter / argument pair, in
+  /// order.
+  bool needExactType(unsigned ParamIdx, const TemplateArgument &Arg) {
+    // We need correct types when the template-name is unresolved or when it
+    // names a template that is able to be overloaded.
+    if (!ResolvedTemplate || SeenPackExpansionIntoNonPack)
+      return true;
+
+    // If we encounter a pack argument that is expanded into a non-pack
+    // parameter, we can no longer track parameter / argument correspondence,
+    // and need to use exact types from this point onwards.
+    assert(ParamIdx < ResolvedTemplate->getTemplateParameters()->size() &&
+           "no parameter for argument");
+    const NamedDecl *Param =
+        ResolvedTemplate->getTemplateParameters()->getParam(ParamIdx);
+    if (!Param->isParameterPack() && Arg.isPackExpansion()) {
+      SeenPackExpansionIntoNonPack = true;
+      return true;
+    }
+
+    assert(Param->isParameterPack() ==
+               (Arg.getKind() == TemplateArgument::Pack) &&
+           "should have formed pack argument for pack parameter");
+
+    // We need exact types for function template arguments because they might be
+    // overloaded on template parameter type. As a special case, a member
+    // function template of a generic lambda is not overloadable.
+    if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ResolvedTemplate)) {
+      auto *RD = dyn_cast<CXXRecordDecl>(FTD->getDeclContext());
+      if (!RD || !RD->isGenericLambda())
+        return true;
+    }
+
+    // Otherwise, we only need a correct type if the parameter has a deduced
+    // type.
+    auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param);
+    return NTTP && NTTP->getType()->getContainedDeducedType();
+  }
+};
+}
+
+void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
+                                        const TemplateArgumentLoc *TemplateArgs,
                                         unsigned NumTemplateArgs) {
   // <template-args> ::= I <template-arg>+ E
   Out << 'I';
+  TemplateArgManglingInfo Info(TN);
   for (unsigned i = 0; i != NumTemplateArgs; ++i)
-    mangleTemplateArg(TemplateArgs[i].getArgument());
+    mangleTemplateArg(TemplateArgs[i].getArgument(),
+                      Info.needExactType(i, TemplateArgs[i].getArgument()));
   Out << 'E';
 }
 
-void CXXNameMangler::mangleTemplateArgs(const TemplateArgumentList &AL) {
+void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
+                                        const TemplateArgumentList &AL) {
   // <template-args> ::= I <template-arg>+ E
   Out << 'I';
+  TemplateArgManglingInfo Info(TN);
   for (unsigned i = 0, e = AL.size(); i != e; ++i)
-    mangleTemplateArg(AL[i]);
+    mangleTemplateArg(AL[i], Info.needExactType(i, AL[i]));
   Out << 'E';
 }
 
-void CXXNameMangler::mangleTemplateArgs(const TemplateArgument *TemplateArgs,
+void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
+                                        const TemplateArgument *TemplateArgs,
                                         unsigned NumTemplateArgs) {
   // <template-args> ::= I <template-arg>+ E
   Out << 'I';
+  TemplateArgManglingInfo Info(TN);
   for (unsigned i = 0; i != NumTemplateArgs; ++i)
-    mangleTemplateArg(TemplateArgs[i]);
+    mangleTemplateArg(TemplateArgs[i], Info.needExactType(i, TemplateArgs[i]));
   Out << 'E';
 }
 
-void CXXNameMangler::mangleTemplateArg(TemplateArgument A) {
+void CXXNameMangler::mangleTemplateArg(TemplateArgument A, bool NeedExactType) {
   // <template-arg> ::= <type>              # type or template
   //                ::= X <expression> E    # expression
   //                ::= <expr-primary>      # simple expressions
   //                ::= J <template-arg>* E # argument pack
   if (!A.isInstantiationDependent() || A.isDependent())
     A = Context.getASTContext().getCanonicalTemplateArgument(A);
 
   switch (A.getKind()) {
case TemplateArgument::Integral:
     break;
   case TemplateArgument::Declaration: {
     //  <expr-primary> ::= L <mangled-name> E # external name
     ValueDecl *D = A.getAsDecl();
 
     // Template parameter objects are modeled by reproducing a source form
     // produced as if by aggregate initialization.
     if (A.getParamTypeForDecl()->isRecordType()) {
-      Out << 'X';
       auto *TPO = cast<TemplateParamObjectDecl>(D);
       mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
-                               TPO->getValue());
-      Out << 'E';
+                               TPO->getValue(), /*TopLevel=*/true,
+                               NeedExactType);
       break;
     }
 
-    // Clang produces AST's where pointer-to-member-function expressions
-    // and pointer-to-function expressions are represented as a declaration not
-    // an expression. We compensate for it here to produce the correct mangling.
-    bool compensateMangling = !A.getParamTypeForDecl()->isReferenceType();
-    if (compensateMangling) {
-      Out << 'X';
-      mangleOperatorName(OO_Amp, 1);
-    }
-
-    mangleDeclRefExpr(D);
-
-    if (compensateMangling)
-      Out << 'E';
-
+    ASTContext &Ctx = Context.getASTContext();
+    APValue Value;
+    if (D->isCXXInstanceMember())
+      // Simple pointer-to-member with no conversion.
+      Value = APValue(D, /*IsDerivedMember=*/false, /*Path=*/{});
+    else if (D->getType()->isArrayType() &&
+             Ctx.hasSimilarType(Ctx.getDecayedType(D->getType()),
+                                A.getParamTypeForDecl()) &&
+             Ctx.getLangOpts().getClangABICompat() >
+                 LangOptions::ClangABI::Ver11)
+      // Build a value corresponding to this implicit array-to-pointer decay.
+      Value = APValue(APValue::LValueBase(D), CharUnits::Zero(),
+                      {APValue::LValuePathEntry::ArrayIndex(0)},
+                      /*OnePastTheEnd=*/false);
+    else
+      // Regular pointer or reference to a declaration.
+      Value = APValue(APValue::LValueBase(D), CharUnits::Zero(),
+                      ArrayRef<APValue::LValuePathEntry>(),
+                      /*OnePastTheEnd=*/false);
+    mangleValueInTemplateArg(A.getParamTypeForDecl(), Value, /*TopLevel=*/true,
+                             NeedExactType);
     break;
   }
   case TemplateArgument::NullPtr: {
     mangleNullPointer(A.getNullPtrType());
     break;
   }
   case TemplateArgument::Pack: {
     //  <template-arg> ::= J <template-arg>* E
     Out << 'J';
     for (const auto &P : A.pack_elements())
-      mangleTemplateArg(P);
+      mangleTemplateArg(P, NeedExactType);
     Out << 'E';
   }
   }
 }
 
 /// Determine whether a given value is equivalent to zero-initialization for
 /// the purpose of discarding a trailing portion of a 'tl' mangling.
 ///
static bool isZeroInitialized(QualType T, const APValue &V) {
 
   case APValue::MemberPointer:
     return !V.getMemberPointerDecl();
   }
 
   llvm_unreachable("Unhandled APValue::ValueKind enum");
 }
 
-void CXXNameMangler::mangleValueInTemplateArg(QualType T, const APValue &V) {
+static QualType getLValueType(ASTContext &Ctx, const APValue &LV) {
+  QualType T = LV.getLValueBase().getType();
+  for (APValue::LValuePathEntry E : LV.getLValuePath()) {
+    if (const ArrayType *AT = Ctx.getAsArrayType(T))
+      T = AT->getElementType();
+    else if (const FieldDecl *FD =
+                 dyn_cast<FieldDecl>(E.getAsBaseOrMember().getPointer()))
+      T = FD->getType();
+    else
+      T = Ctx.getRecordType(
+          cast<CXXRecordDecl>(E.getAsBaseOrMember().getPointer()));
+  }
+  return T;
+}
+
+void CXXNameMangler::mangleValueInTemplateArg(QualType T, const APValue &V,
+                                              bool TopLevel,
+                                              bool NeedExactType) {
   // Ignore all top-level cv-qualifiers, to match GCC.
   Qualifiers Quals;
   T = getASTContext().getUnqualifiedArrayType(T, Quals);
 
+  // A top-level expression that's not a primary expression is wrapped in X...E.
+  bool IsPrimaryExpr = true;
+  auto NotPrimaryExpr = [&] {
+    if (TopLevel && IsPrimaryExpr)
+      Out << 'X';
+    IsPrimaryExpr = false;
+  };
+
   // Proposed in https://github.com/itanium-cxx-abi/cxx-abi/issues/63.
   switch (V.getKind()) {
   case APValue::None:
   case APValue::Indeterminate:
     Out << 'L';
     mangleType(T);
     Out << 'E';
-    return;
+    break;
 
   case APValue::AddrLabelDiff:
     llvm_unreachable("unexpected value kind in template argument");
 
   case APValue::Struct: {
     const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
     assert(RD && "unexpected type for record value");
 
case APValue::Struct: {
     if (Fields.empty()) {
       while (!Bases.empty() &&
              isZeroInitialized(Bases.back().getType(),
                                V.getStructBase(Bases.size() - 1)))
         Bases = Bases.drop_back();
     }
 
     // <expression> ::= tl <type> <braced-expression>* E
+    NotPrimaryExpr();
     Out << "tl";
     mangleType(T);
     for (unsigned I = 0, N = Bases.size(); I != N; ++I)
-      mangleValueInTemplateArg(Bases[I].getType(), V.getStructBase(I));
+      mangleValueInTemplateArg(Bases[I].getType(), V.getStructBase(I), false);
     for (unsigned I = 0, N = Fields.size(); I != N; ++I) {
       if (Fields[I]->isUnnamedBitfield())
         continue;
       mangleValueInTemplateArg(Fields[I]->getType(),
-                               V.getStructField(Fields[I]->getFieldIndex()));
+                               V.getStructField(Fields[I]->getFieldIndex()),
+                               false);
     }
     Out << 'E';
-    return;
+    break;
   }
 
   case APValue::Union: {
     assert(T->getAsCXXRecordDecl() && "unexpected type for union value");
     const FieldDecl *FD = V.getUnionField();
 
     if (!FD) {
       Out << 'L';
       mangleType(T);
       Out << 'E';
-      return;
+      break;
     }
 
     // <braced-expression> ::= di <field source-name> <braced-expression>
+    NotPrimaryExpr();
     Out << "tl";
     mangleType(T);
     if (!isZeroInitialized(T, V)) {
       Out << "di";
       mangleSourceName(FD->getIdentifier());
-      mangleValueInTemplateArg(FD->getType(), V.getUnionValue());
+      mangleValueInTemplateArg(FD->getType(), V.getUnionValue(), false);
     }
     Out << 'E';
-    return;
+    break;
   }
 
   case APValue::Array: {
     QualType ElemT(T->getArrayElementTypeNoTypeQual(), 0);
 
+    NotPrimaryExpr();
     Out << "tl";
     mangleType(T);
 
     // Drop trailing zero-initialized elements.
     unsigned N = V.getArraySize();
     if (!V.hasArrayFiller() || isZeroInitialized(ElemT, V.getArrayFiller())) {
       N = V.getArrayInitializedElts();
       while (N && isZeroInitialized(ElemT, V.getArrayInitializedElt(N - 1)))
         --N;
     }
 
     for (unsigned I = 0; I != N; ++I) {
       const APValue &Elem = I < V.getArrayInitializedElts()
                                 ? V.getArrayInitializedElt(I)
                                 : V.getArrayFiller();
-      mangleValueInTemplateArg(ElemT, Elem);
+      mangleValueInTemplateArg(ElemT, Elem, false);
     }
     Out << 'E';
-    return;
+    break;
   }
 
   case APValue::Vector: {
     const VectorType *VT = T->castAs<VectorType>();
 
+    NotPrimaryExpr();
     Out << "tl";
     mangleType(T);
     unsigned N = V.getVectorLength();
     while (N && isZeroInitialized(VT->getElementType(), V.getVectorElt(N - 1)))
       --N;
     for (unsigned I = 0; I != N; ++I)
-      mangleValueInTemplateArg(VT->getElementType(), V.getVectorElt(I));
+      mangleValueInTemplateArg(VT->getElementType(), V.getVectorElt(I), false);
     Out << 'E';
-    return;
+    break;
   }
 
   case APValue::Int:
     mangleIntegerLiteral(T, V.getInt());
-    return;
+    break;
 
   case APValue::Float:
     mangleFloatLiteral(T, V.getFloat());
-    return;
+    break;
 
   case APValue::FixedPoint:
     mangleFixedPointLiteral();
-    return;
+    break;
 
   case APValue::ComplexFloat: {
     const ComplexType *CT = T->castAs<ComplexType>();
+    NotPrimaryExpr();
     Out << "tl";
     mangleType(T);
     if (!V.getComplexFloatReal().isPosZero() ||
         !V.getComplexFloatImag().isPosZero())
       mangleFloatLiteral(CT->getElementType(), V.getComplexFloatReal());
     if (!V.getComplexFloatImag().isPosZero())
       mangleFloatLiteral(CT->getElementType(), V.getComplexFloatImag());
     Out << 'E';
-    return;
+    break;
   }
 
   case APValue::ComplexInt: {
     const ComplexType *CT = T->castAs<ComplexType>();
+    NotPrimaryExpr();
     Out << "tl";
     mangleType(T);
     if (V.getComplexIntReal().getBoolValue() ||
         V.getComplexIntImag().getBoolValue())
       mangleIntegerLiteral(CT->getElementType(), V.getComplexIntReal());
     if (V.getComplexIntImag().getBoolValue())
       mangleIntegerLiteral(CT->getElementType(), V.getComplexIntImag());
     Out << 'E';
-    return;
+    break;
   }
 
   case APValue::LValue: {
     // Proposed in https://github.com/itanium-cxx-abi/cxx-abi/issues/47.
     assert((T->isPointerType() || T->isReferenceType()) &&
            "unexpected type for LValue template arg");
 
     if (V.isNullPointer()) {
       mangleNullPointer(T);
-      return;
+      break;
     }
 
     APValue::LValueBase B = V.getLValueBase();
     if (!B) {
       // Non-standard mangling for integer cast to a pointer; this can only
       // occur as an extension.
       CharUnits Offset = V.getLValueOffset();
       if (Offset.isZero()) {
         // This is reinterpret_cast<T*>(0), not a null pointer. Mangle this as
         // a cast, because L <type> 0 E means something else.
+        NotPrimaryExpr();
         Out << "rc";
         mangleType(T);
         Out << "Li0E";
+        if (TopLevel)
+          Out << 'E';
       } else {
         Out << "L";
         mangleType(T);
         Out << Offset.getQuantity() << 'E';
       }
-      return;
+      break;
     }
 
+    ASTContext &Ctx = Context.getASTContext();
+
     enum { Base, Offset, Path } Kind;
     if (!V.hasLValuePath()) {
       // Mangle as (T*)((char*)&base + N).
       if (T->isReferenceType()) {
+        NotPrimaryExpr();
         Out << "decvP";
         mangleType(T->getPointeeType());
       } else {
+        NotPrimaryExpr();
         Out << "cv";
         mangleType(T);
       }
       Out << "plcvPcad";
       Kind = Offset;
     } else {
+      if (!V.getLValuePath().empty() || V.isLValueOnePastTheEnd()) {
+        NotPrimaryExpr();
+        // A final conversion to the template parameter's type is usually
+        // folded into the 'so' mangling, but we can't do that for 'void*'
+        // parameters without introducing collisions.
+        if (NeedExactType && T->isVoidPointerType()) {
+          Out << "cv";
+          mangleType(T);
+        }
         if (T->isPointerType())
           Out << "ad";
-      if (!V.getLValuePath().empty() || V.isLValueOnePastTheEnd()) {
         Out << "so";
-        mangleType(T->getPointeeType());
+        mangleType(T->isVoidPointerType()
+                       ? getLValueType(Ctx, V).getUnqualifiedType()
+                       : T->getPointeeType());
         Kind = Path;
       } else {
+        if (NeedExactType &&
+            !Ctx.hasSameType(T->getPointeeType(), getLValueType(Ctx, V)) &&
+            Ctx.getLangOpts().getClangABICompat() >
+                LangOptions::ClangABI::Ver11) {
+          NotPrimaryExpr();
+          Out << "cv";
+          mangleType(T);
+        }
+        if (T->isPointerType()) {
+          NotPrimaryExpr();
+          Out << "ad";
+        }
         Kind = Base;
       }
     }
 
-    QualType TypeSoFar;
+    QualType TypeSoFar = B.getType();
     if (auto *VD = B.dyn_cast<const ValueDecl*>()) {
       Out << 'L';
       mangle(VD);
       Out << 'E';
-      TypeSoFar = VD->getType();
     } else if (auto *E = B.dyn_cast<const Expr*>()) {
+      NotPrimaryExpr();
       mangleExpression(E);
-      TypeSoFar = E->getType();
     } else if (auto TI = B.dyn_cast<TypeInfoLValue>()) {
+      NotPrimaryExpr();
       Out << "ti";
       mangleType(QualType(TI.getType(), 0));
-      TypeSoFar = B.getTypeInfoType();
     } else {
       // We should never see dynamic allocations here.
       llvm_unreachable("unexpected lvalue base kind in template argument");
     }
 
     switch (Kind) {
     case Base:
       break;
 
     case Offset:
       Out << 'L';
-      mangleType(Context.getASTContext().getPointerDiffType());
+      mangleType(Ctx.getPointerDiffType());
       mangleNumber(V.getLValueOffset().getQuantity());
       Out << 'E';
       break;
 
     case Path:
       // <expression> ::= so <referent type> <expr> [<offset number>]
       //                  <union-selector>* [p] E
       if (!V.getLValueOffset().isZero())
case Path:
             // <union-selector> ::= _ <number>
             if (FD->getParent()->isUnion()) {
               Out << '_';
               if (FD->getFieldIndex())
                 Out << (FD->getFieldIndex() - 1);
             }
             TypeSoFar = FD->getType();
           } else {
-            TypeSoFar =
-                Context.getASTContext().getRecordType(cast<CXXRecordDecl>(D));
+            TypeSoFar = Ctx.getRecordType(cast<CXXRecordDecl>(D));
           }
         }
       }
 
       if (OnePastTheEnd)
         Out << 'p';
       Out << 'E';
       break;
     }
 
-    return;
+    break;
   }
 
   case APValue::MemberPointer:
     // Proposed in https://github.com/itanium-cxx-abi/cxx-abi/issues/47.
     if (!V.getMemberPointerDecl()) {
       mangleNullPointer(T);
-      return;
+      break;
     }
 
+    ASTContext &Ctx = Context.getASTContext();
+
+    NotPrimaryExpr();
     if (!V.getMemberPointerPath().empty()) {
       Out << "mc";
       mangleType(T);
+    } else if (NeedExactType &&
+               !Ctx.hasSameType(
+                   T->castAs<MemberPointerType>()->getPointeeType(),
+                   V.getMemberPointerDecl()->getType()) &&
+               Ctx.getLangOpts().getClangABICompat() >
+                   LangOptions::ClangABI::Ver11) {
+      Out << "cv";
+      mangleType(T);
     }
     Out << "adL";
     mangle(V.getMemberPointerDecl());
     Out << 'E';
     if (!V.getMemberPointerPath().empty()) {
       CharUnits Offset =
           Context.getASTContext().getMemberPointerPathAdjustment(V);
       if (!Offset.isZero())
         mangleNumber(Offset.getQuantity());
       Out << 'E';
     }
-    return;
+    break;
   }
+
+  if (TopLevel && !IsPrimaryExpr)
+    Out << 'E';
 }
 
 void CXXNameMangler::mangleTemplateParameter(unsigned Depth, unsigned Index) {
   // <template-param> ::= T_    # first template parameter
   //                  ::= T <parameter-2 non-negative number> _
   //                  ::= TL <L-1 non-negative number> __
   //                  ::= TL <L-1 non-negative number> _
   //                         <parameter-2 non-negative number> _

clang/lib/AST/StmtProfile.cpp

case TemplateArgument::Type:
     break;
 
   case TemplateArgument::Template:
   case TemplateArgument::TemplateExpansion:
     VisitTemplateName(Arg.getAsTemplateOrTemplatePattern());
     break;
 
   case TemplateArgument::Declaration:
+    VisitType(Arg.getParamTypeForDecl());
+    // FIXME: Do we need to recursively decompose template parameter objects?
     VisitDecl(Arg.getAsDecl());
     break;
 
   case TemplateArgument::NullPtr:
     VisitType(Arg.getNullPtrType());
     break;
 
   case TemplateArgument::Integral:
-    Arg.getAsIntegral().Profile(ID);
     VisitType(Arg.getIntegralType());
+    Arg.getAsIntegral().Profile(ID);
     break;
 
   case TemplateArgument::Expression:
     Visit(Arg.getAsExpr());
     break;
 
   case TemplateArgument::Pack:
     for (const auto &P : Arg.pack_elements())

clang/lib/AST/TemplateBase.cpp

case Type:
     getAsType().Profile(ID);
     break;
 
   case NullPtr:
     getNullPtrType().Profile(ID);
     break;
 
   case Declaration:
+    getParamTypeForDecl().Profile(ID);
     ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr);
     break;
 
   case Template:
   case TemplateExpansion: {
     TemplateName Template = getAsTemplateOrTemplatePattern();
     if (TemplateTemplateParmDecl *TTP
           = dyn_cast_or_null<TemplateTemplateParmDecl>(

clang/test/CodeGenCXX/clang-abi-compat.cpp

-// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=3.0 %s -emit-llvm -o - | FileCheck --check-prefixes=PRE39,PRE5,PRE12 %s
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=3.8 %s -emit-llvm -o - | FileCheck --check-prefixes=PRE39,PRE5,PRE12 %s
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=3.9 %s -emit-llvm -o - | FileCheck --check-prefixes=V39,PRE5,PRE12 %s
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=4.0 %s -emit-llvm -o - | FileCheck --check-prefixes=V39,PRE5,PRE12 %s
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=5 %s -emit-llvm -o - | FileCheck --check-prefixes=V39,V5,PRE12 %s
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=11 %s -emit-llvm -o - | FileCheck --check-prefixes=V11,V5,PRE12 %s
-// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=latest %s -emit-llvm -o - | FileCheck --check-prefixes=V39,V5,V12 %s
+// RUN: %clang_cc1 -std=c++98 -triple x86_64-linux-gnu -fclang-abi-compat=3.0 %s -emit-llvm -o -    | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12 %s
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=3.0 %s -emit-llvm -o -    | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12 %s
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=3.8 %s -emit-llvm -o -    | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12 %s
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=3.9 %s -emit-llvm -o -    | FileCheck --check-prefixes=CHECK,V39,PRE5,PRE12 %s
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=4.0 %s -emit-llvm -o -    | FileCheck --check-prefixes=CHECK,V39,PRE5,PRE12 %s
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=5 %s -emit-llvm -o -      | FileCheck --check-prefixes=CHECK,V39,V5,PRE12,PRE12-CXX17 %s
+// RUN: %clang_cc1 -std=c++17 -triple x86_64-linux-gnu -fclang-abi-compat=11 %s -emit-llvm -o -     | FileCheck --check-prefixes=CHECK,V39,V5,PRE12,PRE12-CXX17 %s
+// RUN: %clang_cc1 -std=c++98 -triple x86_64-linux-gnu -fclang-abi-compat=latest %s -emit-llvm -o - | FileCheck --check-prefixes=CHECK,V39,V5,V12 %s
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-linux-gnu -fclang-abi-compat=latest %s -emit-llvm -o - | FileCheck --check-prefixes=CHECK,V39,V5,V12,V12-CXX17 %s
 
 typedef __attribute__((vector_size(8))) long long v1xi64;
 void clang39(v1xi64) {}
 // PRE39: @_Z7clang39Dv1_x(i64
 // V39: @_Z7clang39Dv1_x(double
 
 struct A {
   A(const A&) = default;
   A(A&&);
 };
 void clang5(A) {}
 // PRE5: @_Z6clang51A()
 // V5: @_Z6clang51A(%{{.*}}*
 
 namespace mangle_template_prefix {
   // PRE12: @_ZN22mangle_template_prefix1fINS_1TEEEvNT_1UIiE1VIiEENS4_S5_IfEE(
   // V12: @_ZN22mangle_template_prefix1fINS_1TEEEvNT_1UIiE1VIiEENS5_IfEE(
   template<typename T> void f(typename T::template U<int>::template V<int>, typename T::template U<int>::template V<float>);
   struct T { template<typename I> struct U { template<typename J> using V = int; }; };
   void g() { f<T>(1, 2); }
 }
 
+int arg;
+template<const int *> struct clang12_unchanged {};
+// CHECK: @_Z4test17clang12_unchangedIXadL_Z3argEEE
+void test(clang12_unchanged<&arg>) {}
+
+#if __cplusplus >= 201703L
+// PRE12-CXX17: @_Z4test15clang12_changedIXadL_Z3argEEE
+// V12-CXX17: @_Z4test15clang12_changedIXcvPKiadL_Z3argEEE
+template<auto> struct clang12_changed {};
+void test(clang12_changed<(const int*)&arg>) {}
+#endif
+
+// PRE12: @_Z9clang12_aIXadL_Z3argEEEvv
+// V12: @_Z9clang12_aIXcvPKiadL_Z3argEEEvv
+template<const int *> void clang12_a() {}
+template void clang12_a<&arg>();
+
+// PRE12: @_Z9clang12_bIXadL_Z3arrEEEvv
+// V12: @_Z9clang12_bIXadsoKcL_Z3arrEEEEvv
+extern const char arr[6] = "hello";
+template<const char *> void clang12_b() {}
+template void clang12_b<arr>();
+
+// CHECK: @_Z9clang12_cIXadL_Z3arrEEEvv
+template<const char (*)[6]> void clang12_c() {}
+template void clang12_c<&arr>();

clang/test/CodeGenCXX/mangle-class-nttp.cpp

union E {
   float f;
   constexpr E() {}
   constexpr E(int n) : n(n) {}
   constexpr E(float f) : f(f) {}
 };
 template<E> void f() {}
 
 // Union members.
-// CHECK: define weak_odr void @_Z1fIXL1EEEEvv(
+// CHECK: define weak_odr void @_Z1fIL1EEEvv(
 // MSABI: define {{.*}} @"??$f@$7TE@@@@@YAXXZ"
 template void f<E{}>();
 // CHECK: define weak_odr void @_Z1fIXtl1EEEEvv(
 // MSABI: define {{.*}} @"??$f@$7TE@@n@0A@@@@YAXXZ"
 template void f<E(0)>();
 // CHECK: define weak_odr void @_Z1fIXtl1Edi1nLi42EEEEvv(
 // MSABI: define {{.*}} @"??$f@$7TE@@n@0CK@@@@YAXXZ"
 template void f<E(42)>();

 union H1 {};
 union H2 { int : 1, : 2, : 3; };
 union H3 { int : 1, a, : 2, b, : 3; };
 struct H4 { H2 h2; };
 template<H1> void f() {}
 template<H2> void f() {}
 template<H3> void f() {}
 template<H4> void f() {}
-// CHECK: define weak_odr void @_Z1fIXL2H1EEEvv
+// CHECK: define weak_odr void @_Z1fIL2H1EEvv
 // MSABI: define {{.*}} @"??$f@$7TH1@@@@@YAXXZ"
 template void f<H1{}>();
-// CHECK: define weak_odr void @_Z1fIXL2H2EEEvv
+// CHECK: define weak_odr void @_Z1fIL2H2EEvv
 // MSABI: define {{.*}} @"??$f@$7TH2@@@@@YAXXZ"
 template void f<H2{}>();
 // CHECK: define weak_odr void @_Z1fIXtl2H3EEEvv
 // MSABI: define {{.*}} @"??$f@$7TH3@@a@0A@@@@YAXXZ"
 template void f<H3{.a = 0}>();
 // CHECK: define weak_odr void @_Z1fIXtl2H3di1aLi1EEEEvv
 // MSABI: define {{.*}} @"??$f@$7TH3@@a@00@@@YAXXZ"
 template void f<H3{.a = 1}>();

clang/test/CodeGenCXX/mangle-template.cpp

 // RUN: %clang_cc1 -verify -Wno-return-type -Wno-main -std=c++11 -emit-llvm -triple %itanium_abi_triple -o - %s | FileCheck %s
+// RUN: %clang_cc1 -verify -Wno-return-type -Wno-main -std=c++20 -emit-llvm -triple x86_64-linux-gnu -o - %s | FileCheck %s --check-prefixes=CHECK,CXX20
 // expected-no-diagnostics
 
 namespace test1 {
 int x;
 template <int& D> class T { };
 // CHECK: void @_ZN5test12f0ENS_1TIL_ZNS_1xEEEE(
 void f0(T<x> a0) {}
 }

 namespace test16 {
   // Ensure we properly form substitutions for template names in prefixes.
   // CHECK: @_ZN6test161fINS_1TEEEvNT_1UIiE1VIiEENS5_IfEE
   template<typename T> void f(typename T::template U<int>::template V<int>, typename T::template U<int>::template V<float>);
   struct T { template<typename I> struct U { template<typename J> using V = int; }; };
   void g() { f<T>(1, 2); }
 }
 
+#if __cplusplus >= 202002L
+namespace cxx20 {
+  template<auto> struct A {};
+  template<typename T, T V> struct B {};
+
+  int x;
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1AIXadL_ZNS_1xEEEEE(
+  void f(A<&x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1BIPiXadL_ZNS_1xEEEEE(
+  void f(B<int*, &x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1AIXcvPKiadL_ZNS_1xEEEEE(
+  void f(A<(const int*)&x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1BIPKiXadL_ZNS_1xEEEEE(
+  void f(B<const int*, &x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1AIXcvPvadL_ZNS_1xEEEEE(
+  void f(A<(void*)&x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1BIPvXadL_ZNS_1xEEEEE(
+  void f(B<void*, (void*)&x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1AIXcvPKvadL_ZNS_1xEEEEE(
+  void f(A<(const void*)&x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1BIPKvXadL_ZNS_1xEEEEE(
+  void f(B<const void*, (const void*)&x>) {}
+
+  struct Q { int x; };
+
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1AIXadL_ZNS_1Q1xEEEEE(
+  void f(A<&Q::x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1BIMNS_1QEiXadL_ZNS1_1xEEEEE
+  void f(B<int Q::*, &Q::x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1AIXcvMNS_1QEKiadL_ZNS1_1xEEEEE(
+  void f(A<(const int Q::*)&Q::x>) {}
+  // CXX20: define {{.*}} @_ZN5cxx201fENS_1BIMNS_1QEKiXadL_ZNS1_1xEEEEE(
+  void f(B<const int Q::*, (const int Q::*)&Q::x>) {}
+}
+#endif
+
+namespace test17 {
+  // Ensure we mangle the types for non-type template arguments if we've lost
+  // track of argument / parameter correspondence.
+  template<int A, int ...B> struct X {};
+
+  // CHECK: define {{.*}} @_ZN6test171fILi1EJLi2ELi3ELi4EEEEvNS_1XIXT_EJLi5EXspT0_ELi6EEEE
+  template<int D, int ...C> void f(X<D, 5u, C..., 6u>) {}
+  void g() { f<1, 2, 3, 4>({}); }
+
+  // Note: there is no J...E here, because we can't form a pack argument, and
+  // the 5u and 6u are mangled with the original type 'j' (unsigned int) not
+  // with the resolved type 'i' (signed int).
+  // CHECK: define {{.*}} @_ZN6test171hILi4EJLi1ELi2ELi3EEEEvNS_1XIXspT0_EXLj5EEXT_EXLj6EEEE
+  template<int D, int ...C> void h(X<C..., 5u, D, 6u>) {}
+  void i() { h<4, 1, 2, 3>({}); }
+
+#if __cplusplus >= 201402L
+  template<int A, const volatile int*> struct Y {};
+  int n;
+  // Case 1: &n is a resolved template argument, with a known parameter:
+  // mangled with no conversion.
+  // CXX20: define {{.*}} @_ZN6test172j1ILi1EEEvNS_1YIXT_EXadL_ZNS_1nEEEEE
+  template<int N> void j1(Y<N, (const int*)&n>) {}
+  // Case 2: &n is an unresolved template argument, with an unknown
+  // corresopnding parameter: mangled as the source expression.
+  // CXX20: define {{.*}} @_ZN6test172j2IJLi1EEEEvNS_1YIXspT_EXcvPKiadL_ZNS_1nEEEEE
+  template<int ...Ns> void j2(Y<Ns..., (const int*)&n>) {}
+  // Case 3: &n is a resolved template argument, with a known parameter, but
+  // for a template that can be overloaded on type: mangled with the parameter type.
+  // CXX20: define {{.*}} @_ZN6test172j3ILi1EEEvDTplT_clL_ZNS_1yIXcvPVKiadL_ZNS_1nEEEEEivEEE
+  template<const volatile int*> int y();
+  template<int N> void j3(decltype(N + y<(const int*)&n>())) {}
+  void k() {
+    j1<1>(Y<1, &n>());
+    j2<1>(Y<1, &n>());
+    j3<1>(0);
+  }
+#endif
+}

clang/test/SemaTemplate/temp_arg_nontype_cxx1z.cpp

namespace Basic {
     template<auto** pp> class B<pp> { };
     template<auto* p0>   int &f(B<p0> b); // expected-note {{candidate}}
     template<auto** pp0> float &f(B<pp0> b); // expected-note {{candidate}}
 
     int a, *b = &a;
     int &r = f(B<&a>());
     float &s = f(B<&b>());
 
+    void type_affects_identity(B<&a>) {}
+    void type_affects_identity(B<(const int*)&a>) {}
+    void type_affects_identity(B<(void*)&a>) {}
+    void type_affects_identity(B<(const void*)&a>) {}
+
     // pointers to members
     template<typename T, auto *T::*p> struct B<p> {};
     template<typename T, auto **T::*p> struct B<p> {};
     template<typename T, auto *T::*p0>   char &f(B<p0> b); // expected-note {{candidate}}
     template<typename T, auto **T::*pp0> short &f(B<pp0> b); // expected-note {{candidate}}
 
     struct X { int n; int *p; int **pp; typedef int a, b; };
     auto t = f(B<&X::n>()); // expected-error {{no match}}
     char &u = f(B<&X::p>());
     short &v = f(B<&X::pp>());
 
+    struct Y : X {};
+    void type_affects_identity(B<&X::n>) {}
+    void type_affects_identity(B<(int Y::*)&X::n>) {} // FIXME: expected-error {{sorry}}
+    void type_affects_identity(B<(const int X::*)&X::n>) {}
+    void type_affects_identity(B<(const int Y::*)&X::n>) {} // FIXME: expected-error {{sorry}}
+
     // A case where we need to do auto-deduction, and check whether the
     // resulting dependent types match during partial ordering. These
     // templates are not ordered due to the mismatching function parameter.
     template<typename T, auto *(*f)(T, typename T::a)> struct B<f> {}; // expected-note {{matches}}
     template<typename T, auto **(*f)(T, typename T::b)> struct B<f> {}; // expected-note {{matches}}
     int **g(X, int);
     B<&g> bg; // expected-error {{ambiguous}}
   }