Mark identifier prefixes as substitutable

[hvdijk]

Summary

The Itanium C++ ABI says prefixes are substitutable. For most prefixes we already handle this: the manglePrefix(const DeclContext *, bool) and manglePrefix(QualType) overloads explicitly handles substitutions or defer to functions that handle substitutions on their behalf. The manglePrefix(NestedNameSpecifier *) overload, however, is different and handles some cases implicitly, but not all. The Identifier case was not handled; this change adds handling for it, as well as a test case.

[hvdijk]

Question: does this need to be covered by -fclang-abi-compat= when the prior mangling resulted in names that even llvm-cxxfilt agreed made no sense? (If it is needed, it should be an easy change.)

[hvdijk]

ping. Apologies, I don't know who to add as a reviewer, there is no one specifically listed as code owner and it does not seem to be handled by anyone in particular. @urnathan, @erichkeane, you two appear to be the most recent people who pushed commits specifically for mangling issues, would either of you be able to review this?

[erichkeane]

@rjmccall is the expert on the Itanium ABI.

Code wise, I have no real comments, though he might. As far as:

Question: does this need to be covered by -fclang-abi-compat= when the prior mangling resulted in names that even llvm-cxxfilt agreed made no sense? (If it is needed, it should be an easy change.)

I believe the answer here is 'yes'. We also likely need release notes.

[hvdijk]

Allow the old mangling with suitable -fclang-abi-compat= value

[hvdijk]

In D122663#3456507, @erichkeane wrote:

I believe the answer here is 'yes'. We also likely need release notes.

Thanks for the feedback. -fclang-abi-compat= support added. Other mangling bugfixes appear to not have made it into release notes so I did not add it for this one either, but if that is something that's wanted I can add it; I'll wait for some more comments on that.

[erichkeane]

In D122663#3457130, @hvdijk wrote:

In D122663#3456507, @erichkeane wrote:

I believe the answer here is 'yes'. We also likely need release notes.

Thanks for the feedback. -fclang-abi-compat= support added. Other mangling bugfixes appear to not have made it into release notes so I did not add it for this one either, but if that is something that's wanted I can add it; I'll wait for some more comments on that.

Our most recent direction is to document any non-NFC patches in the release notes if at all sensible, so I think this meets those requirements.

[hvdijk]

In D122663#3457131, @erichkeane wrote:

Our most recent direction is to document any non-NFC patches in the release notes if at all sensible, so I think this meets those requirements.

Thanks, I'm not finding documentation of any change in policy even after specifically looking for it, so I have opened https://github.com/llvm/llvm-project/issues/54965 for that. However, I have no issue with the policy and will add a release note for this.

[hvdijk]

Add to release notes.

[erichkeane]

LGTM! I would like @rjmccall to take a pass if he ends up having time in the next day or two (perhaps tack on an extra day or two because of Easter), else I'll be willing to approve later in the week.

[rsmith]

clang/lib/AST/ItaniumMangle.cpp

6028

This seems a little error-prone to me: calling this on a type NNS would do the wrong thing (those are supposed to share a substitution number with the type, rather than have a substitution of their own).

We could handle the various cases here and dispatch to the right forms of mangleSubstitution depending on the kind of NNS, but that code would all be unreachable / untested. So maybe we should just make this assert that NNS->getKind() == NestedNameSpecifier::Identifier. (And optionally we could give this a more specific name, eg mangleSubstitutionForIdentifierNNS?)

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

160

I think this test does not capture an important property for which we should have test coverage: that we used to not register a substitution for T::Y (not only that we used to not *use* a substitution for it). For example, this test would capture that:

struct X {
  struct Y {
    using a = int;
    using b = int;
  };
};
template <typename T> void test10(typename T::Y::a, typename T::Y::b, float*, float*) {}
template void test10<X>(int, int, float*, float*);

... where the numbering of float* depends on how many substitutions we created for the earlier types.

(Put another way, this test covers only one of the two if (!Clang14Compat) tests in ItaniumMangle.cpp, and we should cover both.)

[hvdijk]

Extend test, add assert.

[hvdijk]

clang/lib/AST/ItaniumMangle.cpp

6028

I have added the assert that you suggested. I would actually have preferred for this function to be used for other NNS substitutions as well to better align with how the spec says substitutions should be handled (it's a rule of <prefix>, not any component within) but that seemed like an unnecessarily more invasive change. If you are okay with it I would like to keep the function named just mangleSubstitution to keep that open as option for a possible future clean-up.

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

160

I get where you're coming from. My thinking was the other way around, if we add the first if (!Clang14Compat && ...) by itself that will have no effect and cannot be tested for, then if we add the second if (!Clang14Compat) that does have impact and needs testing. You're looking at it the other way around, if we add the second if (!Clang14Compat) first, we fix one bug, and if we then add the first if (!Clang14Compat && ...) we fix another. Happy to extend the test like you suggested.

[hvdijk]

clang/docs/ReleaseNotes.rst

271

This is incorrect rst syntax.

[hvdijk]

Fixed release notes to use correct RST syntax.

[hvdijk]

In D122663#3457330, @erichkeane wrote:

LGTM! I would like @rjmccall to take a pass if he ends up having time in the next day or two (perhaps tack on an extra day or two because of Easter), else I'll be willing to approve later in the week.

ping, I did get feedback from @rsmith (much appreciated) and applied his suggestions, but not from @rjmccall, would you be okay to approve it then?

[erichkeane]

In D122663#3470687, @hvdijk wrote:

In D122663#3457330, @erichkeane wrote:

LGTM! I would like @rjmccall to take a pass if he ends up having time in the next day or two (perhaps tack on an extra day or two because of Easter), else I'll be willing to approve later in the week.

ping, I did get feedback from @rsmith (much appreciated) and applied his suggestions, but not from @rjmccall, would you be okay to approve it then?

Ping me EOW if @rsmith doesn't respond in the meantime. It is also not clear to me whether you were able to capture/fix the issue he had with the clang-abi-compat.cpp test.

[hvdijk]

In D122663#3471741, @erichkeane wrote:

Ping me EOW if @rsmith doesn't respond in the meantime. It is also not clear to me whether you were able to capture/fix the issue he had with the clang-abi-compat.cpp test.

Will do, sure. For the record, for that test I applied @rsmith's suggestion verbatim so it *should* address his concern, but I will wait for him to confirm.

[erichkeane]

In D122663#3471748, @hvdijk wrote:

In D122663#3471741, @erichkeane wrote:

Ping me EOW if @rsmith doesn't respond in the meantime. It is also not clear to me whether you were able to capture/fix the issue he had with the clang-abi-compat.cpp test.

Will do, sure. For the record, for that test I applied @rsmith's suggestion verbatim so it *should* address his concern, but I will wait for him to confirm.

I DID see that and am REASONABLY sure you do, but sometimes folks will ask for test coverage because they suspect the resulting behavior will demonstrate some sort of problem with the current patch. I DID run this through the demangler and found that the PRE15 case looks odd?

void test10<X>(X::Y::a, X::Y::b, float*, X::Y)
vs
void test10<X>(X::Y::a, X::Y::b, float*, float*)

Or is that exactly the bug being caught here? That is, is the float* substitution not being properly registered/emitted and being confused with X::Y?

PS:, and as an unrelated-lament... A while back I wrote a test regarding mangling where I ALSO had it run us through llvm-cxxfilt so that we had an output of every mangled string that showed the demangled version. I wish we'd done that from the beginning to make it much less confusing what is going on in these.

[urnathan]

[was out last week] It seems the demangler already gets this right, probably because it just looks like a regular nested name

[hvdijk]

In D122663#3471763, @erichkeane wrote:

I DID see that and am REASONABLY sure you do, but sometimes folks will ask for test coverage because they suspect the resulting behavior will demonstrate some sort of problem with the current patch. I DID run this through the demangler and found that the PRE15 case looks odd?

void test10<X>(X::Y::a, X::Y::b, float*, X::Y)
vs
void test10<X>(X::Y::a, X::Y::b, float*, float*)

Or is that exactly the bug being caught here? That is, is the float* substitution not being properly registered/emitted and being confused with X::Y?

Yes, that is exactly it. That is what @rsmith was getting at with his comment about regarding this as two separate bugs (he can correct me if I am misstating things), one that we do not add the substitution and as such use wrong numbers for subsequent substitutions, the other that we do not use the substitution. The other is what I had covered in my initial test, his addition covers that first bug where we wrongly used S4 when we should be using S5.

PS:, and as an unrelated-lament... A while back I wrote a test regarding mangling where I ALSO had it run us through llvm-cxxfilt so that we had an output of every mangled string that showed the demangled version. I wish we'd done that from the beginning to make it much less confusing what is going on in these.

llvm-cxxfilt has no option to be compatible with earlier incorrect mangling though, so it would not help with this particular test. But it could help with other tests, agreed.

[erichkeane]

llvm-cxxfilt has no option to be compatible with earlier incorrect mangling though, so it would not help with this particular test. But it could help with other tests, agreed.

This actually wouldn't be necessary in this case: cxxfilt is already 'right', this is just for humans to be able to see "we changed this from mangling as <obviously wrong> to <looks right>".

[hvdijk]

In D122663#3471866, @erichkeane wrote:

This actually wouldn't be necessary in this case: cxxfilt is already 'right', this is just for humans to be able to see "we changed this from mangling as <obviously wrong> to <looks right>".

That's a good point. We do have tests in clang that use llvm-cxxfilt already (the PPC intrinsic tests) so there should be no problem with it as a dependency; I think once this is in I might submit that as a follow-up change for review unless someone else beats me to it.

[erichkeane]

In D122663#3471960, @hvdijk wrote:

In D122663#3471866, @erichkeane wrote:

This actually wouldn't be necessary in this case: cxxfilt is already 'right', this is just for humans to be able to see "we changed this from mangling as <obviously wrong> to <looks right>".

That's a good point. We do have tests in clang that use llvm-cxxfilt already (the PPC intrinsic tests) so there should be no problem with it as a dependency; I think once this is in I might submit that as a follow-up change for review unless someone else beats me to it.

Any amount of test cleanup in that direction would be greatly appreciated! Even as NFC.

The test I did it for was CodeGenCXX/mangle-nttp-anon-union.cpp as an example of what I'm talking about.

[hvdijk]

In D122663#3471741, @erichkeane wrote:

Ping me EOW if @rsmith doesn't respond in the meantime.

ping

[urnathan]

clang/lib/AST/ItaniumMangle.cpp

6028

One could name it mangleSubstitutionForIdentifierNNS now and rename it in the future, if your unification dream comes true? That names it for what it does now.

Just a thought, not a requirement.

[hvdijk]

clang/lib/AST/ItaniumMangle.cpp

6028

Sorry, that comment came after I pushed it already. I have some more things to look into when I have some more time (including @erichkeane's comment about the test), will see if it makes sense to include with that, or perhaps to just make that NFC change to allow it to be used more generally.

[urnathan]

clang/lib/AST/ItaniumMangle.cpp

6028

no worries, I failed to notice it'd already landed

clang/docs/ReleaseNotes.rst

 
 C++ Language Changes in Clang
 -----------------------------
 
 - Improved ``-O0`` code generation for calls to ``std::move``, ``std::forward``,
   ``std::move_if_noexcept``, ``std::addressof``, and ``std::as_const``. These
   are now treated as compiler builtins and implemented directly, rather than
   instantiating the definition from the standard library.
+- Fixed mangling of nested dependent names such as ``T::a::b``, where ``T`` is a
+  template parameter, to conform to the Itanium C++ ABI and be compatible with
+  GCC. This breaks binary compatibility with code compiled with earlier versions
+  of clang; use the ``-fclang-abi-compat=14`` option to get the old mangling.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 - Diagnose consteval and constexpr issues that happen at namespace scope. This
   partially addresses `Issue 51593 <https://github.com/llvm/llvm-project/issues/51593>`_.
 - No longer attempt to evaluate a consteval UDL function call at runtime when
   it is called through a template instantiation. This fixes
   `Issue 54578 <https://github.com/llvm/llvm-project/issues/54578>`_.

clang/include/clang/Basic/LangOptions.h

enum class ClangABI {
     /// (git 8e464dd76bef). This causes clang to mangle lambdas within
     /// global-scope inline variables incorrectly.
     Ver12,
 
     /// Attempt to be ABI-compatible with code generated by Clang 13.0.x.
     /// This causes clang to not pack non-POD members of packed structs.
     Ver13,
 
+    /// Attempt to be ABI-compatible with code generated by Clang 14.0.x.
+    /// This causes clang to mangle dependent nested names incorrectly.
+    Ver14,
+
     /// Conform to the underlying platform's C and C++ ABIs as closely
     /// as we can.
     Latest
   };
 
   enum class CoreFoundationABI {
     /// No interoperability ABI has been specified
     Unspecified,

clang/lib/AST/ItaniumMangle.cpp

public:
   void mangleType(QualType T);
   void mangleNameOrStandardSubstitution(const NamedDecl *ND);
   void mangleLambdaSig(const CXXRecordDecl *Lambda);
   void mangleModuleNamePrefix(StringRef Name);
 
 private:
 
   bool mangleSubstitution(const NamedDecl *ND);
+  bool mangleSubstitution(NestedNameSpecifier *NNS);
   bool mangleSubstitution(QualType T);
   bool mangleSubstitution(TemplateName Template);
   bool mangleSubstitution(uintptr_t Ptr);
 
   void mangleExistingSubstitution(TemplateName name);
 
   bool mangleStandardSubstitution(const NamedDecl *ND);
 
   void addSubstitution(const NamedDecl *ND) {
     ND = cast<NamedDecl>(ND->getCanonicalDecl());
 
     addSubstitution(reinterpret_cast<uintptr_t>(ND));
   }
+  void addSubstitution(NestedNameSpecifier *NNS) {
+    NNS = Context.getASTContext().getCanonicalNestedNameSpecifier(NNS);
+
+    addSubstitution(reinterpret_cast<uintptr_t>(NNS));
+  }
   void addSubstitution(QualType T);
   void addSubstitution(TemplateName Template);
   void addSubstitution(uintptr_t Ptr);
   // Destructive copy substitutions from other mangler.
   void extendSubstitutions(CXXNameMangler* Other);
 
   void mangleUnresolvedPrefix(NestedNameSpecifier *qualifier,
                               bool recursive = false);
case NestedNameSpecifier::NamespaceAlias:
     return;
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate:
     manglePrefix(QualType(qualifier->getAsType(), 0));
     return;
 
   case NestedNameSpecifier::Identifier:
+    // Clang 14 and before did not consider this substitutable.
+    bool Clang14Compat = getASTContext().getLangOpts().getClangABICompat() <=
+                         LangOptions::ClangABI::Ver14;
+    if (!Clang14Compat && mangleSubstitution(qualifier))
+      return;
+
     // Member expressions can have these without prefixes, but that
     // should end up in mangleUnresolvedPrefix instead.
     assert(qualifier->getPrefix());
     manglePrefix(qualifier->getPrefix());
 
     mangleSourceName(qualifier->getAsIdentifier());
+
+    if (!Clang14Compat)
+      addSubstitution(qualifier);
     return;
   }
 
   llvm_unreachable("unexpected nested name specifier");
 }
 
 void CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) {
   //  <prefix> ::= <prefix> <unqualified-name>
bool CXXNameMangler::mangleSubstitution(const NamedDecl *ND) {
   // Try one of the standard substitutions first.
   if (mangleStandardSubstitution(ND))
     return true;
 
   ND = cast<NamedDecl>(ND->getCanonicalDecl());
   return mangleSubstitution(reinterpret_cast<uintptr_t>(ND));
 }
 
+bool CXXNameMangler::mangleSubstitution(NestedNameSpecifier *NNS) {
+  assert(NNS->getKind() == NestedNameSpecifier::Identifier &&
+         "mangleSubstitution(NestedNameSpecifier *) is only used for "
+         "identifier nested name specifiers.");
+  NNS = Context.getASTContext().getCanonicalNestedNameSpecifier(NNS);
+  return mangleSubstitution(reinterpret_cast<uintptr_t>(NNS));
+}
+
 /// Determine whether the given type has any qualifiers that are relevant for
 /// substitutions.
 static bool hasMangledSubstitutionQualifiers(QualType T) {
   Qualifiers Qs = T.getQualifiers();
   return Qs.getCVRQualifiers() || Qs.hasAddressSpace() || Qs.hasUnaligned();
 }
 
 bool CXXNameMangler::mangleSubstitution(QualType T) {

clang/lib/Frontend/CompilerInvocation.cpp

#undef LANG_OPTION_WITH_MARSHALLING
   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver9)
     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "9.0", SA);
   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver11)
     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "11.0", SA);
   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver12)
     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "12.0", SA);
   else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver13)
     GenerateArg(Args, OPT_fclang_abi_compat_EQ, "13.0", SA);
+  else if (Opts.getClangABICompat() == LangOptions::ClangABI::Ver14)
+    GenerateArg(Args, OPT_fclang_abi_compat_EQ, "14.0", SA);
 
   if (Opts.getSignReturnAddressScope() ==
       LangOptions::SignReturnAddressScopeKind::All)
     GenerateArg(Args, OPT_msign_return_address_EQ, "all", SA);
   else if (Opts.getSignReturnAddressScope() ==
            LangOptions::SignReturnAddressScopeKind::NonLeaf)
     GenerateArg(Args, OPT_msign_return_address_EQ, "non-leaf", SA);
 
if (!VerParts.first.startswith("0") &&
       else if (Major <= 9)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver9);
       else if (Major <= 11)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver11);
       else if (Major <= 12)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver12);
       else if (Major <= 13)
         Opts.setClangABICompat(LangOptions::ClangABI::Ver13);
+      else if (Major <= 14)
+        Opts.setClangABICompat(LangOptions::ClangABI::Ver14);
     } else if (Ver != "latest") {
       Diags.Report(diag::err_drv_invalid_value)
           << A->getAsString(Args) << A->getValue();
     }
   }
 
   if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
     StringRef SignScope = A->getValue();

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

 // RUN: %clang_cc1 -no-opaque-pointers -std=c++98 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=3.0 %s -emit-llvm -o - -Wno-c++11-extensions \
-// RUN:     | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++17 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=3.0 %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++17 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=3.8 %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,PRE39,PRE5,PRE12,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++17 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=3.9 %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,V39,PRE5,PRE12 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,PRE5,PRE12,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++17 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=4.0 %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,V39,PRE5,PRE12 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,PRE5,PRE12,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++17 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=5 %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,PRE12,PRE12-CXX17 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,PRE12,PRE12-CXX17,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++17 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=11 %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,PRE12,PRE12-CXX17 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,PRE12,PRE12-CXX17,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++20 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=11 %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,PRE12,PRE12-CXX17,PRE12-CXX20,PRE13-CXX20 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,PRE12,PRE12-CXX17,PRE12-CXX20,PRE13-CXX20,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++20 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=12 %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,V12,V12-CXX17,V12-CXX20,PRE13-CXX20 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,V12,V12-CXX17,V12-CXX20,PRE13-CXX20,PRE15 %s
+// RUN: %clang_cc1 -no-opaque-pointers -std=c++20 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=14 %s -emit-llvm -o - \
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,V12,V12-CXX17,V12-CXX20,V13-CXX20,PRE15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++98 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=latest %s -emit-llvm -o - -Wno-c++11-extensions \
-// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,V12 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,V12,V15 %s
 // RUN: %clang_cc1 -no-opaque-pointers -std=c++20 -triple x86_64-linux-gnu -fenable-matrix -fclang-abi-compat=latest %s -emit-llvm -o - \
-// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,V12,V12-CXX17,V12-CXX20,V13-CXX20 %s
+// RUN:     | FileCheck --check-prefixes=CHECK,V39,V5,V12,V12-CXX17,V12-CXX20,V13-CXX20,V15 %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;

 #if __cplusplus >= 202002L
 // PRE13-CXX20: @_Z15observe_lambdasI17inline_var_lambdaMUlvE_17inline_var_lambdaMUlvE0_PiS2_S0_S1_EiT_T0_T1_T2_
 // V13-CXX20: @_Z15observe_lambdasIN17inline_var_lambdaMUlvE_ENS0_UlvE0_EPiS3_S1_S2_EiT_T0_T1_T2_
 template <typename T, typename U, typename V, typename W, typename = T, typename = U>
 int observe_lambdas(T, U, V, W) { return 0; }
 inline auto inline_var_lambda = observe_lambdas([]{}, []{}, (int*)0, (int*)0);
 int use_inline_var_lambda() { return inline_var_lambda; }
 #endif
+
+struct X {
+  struct Y {
+    using a = int;
+    using b = int;
+  };
+};
+template <typename T> void test10(typename T::Y::a, typename T::Y::b, float*, float*) {}
+// PRE15: @_Z6test10I1XEvNT_1Y1aENS1_1Y1bEPfS4_
+// V15:   @_Z6test10I1XEvNT_1Y1aENS2_1bEPfS5_
+template void test10<X>(int, int, float*, float*);

clang/test/CodeGenCXX/mangle.cpp

 
 namespace test60 {
   struct X { int i, j; };
   auto [a,b] = X{1,2};
   template<typename T> void f(decltype(a + T())) {}
   // CHECK-LABEL: @_ZN6test601fIiEEvDTplL_ZNS_1aEEcvT__EE
   template void f<int>(int);
 }
+
+namespace test61 {
+  struct X {
+    struct Y {
+      using a = int;
+      using b = int;
+    };
+  };
+  template <typename T> void f(typename T::Y::a, typename T::Y::b) {}
+  // CHECK-LABEL: @_ZN6test611fINS_1XEEEvNT_1Y1aENS3_1bE
+  template void f<X>(int, int);
+}