[clang][ABI] New C++20 module mangling scheme

[urnathan]

Summary

The existing module symbol mangling scheme turns out to be undemangleable. It is also desirable to switch to the strong-ownership model as the hoped-for C++17 compatibility turns out to be fragile, and we also now have a better way of controlling that.

The issue is captured on the ABI list at:

https://github.com/itanium-cxx-abi/cxx-abi/issues/134

A document describing the issues and new mangling is at: (sigh, I wish I cold get a stable name here)
https://drive.google.com/file/d/1XAR2RLzrpAoWGBQcPkxP33s8SwB2y4vb/view?usp=sharing

This patch reimplements the bits of mangling that we already had, it does not implement the other bits mentioned in that document such as global initializer functions or unnamed enumerations (which itself needs adjusting from the doc).

GCC implements this mangling.

The old mangling is unceremoniously dropped. No backwards compatibility, no deprectated old-mangling flag. It was always labelled experimental. (Old and new manglings cannot be confused.)

[erichkeane]

Not exactly my place of expertise, but perhaps others with more modules familiarity can take a look.

clang/lib/AST/ItaniumMangle.cpp

481

I see one instance of us passing around a DeclContext as a nullptr, what is the justification/mechanism for that? I would expect EVERYTHING to have a declaration context, so I would expect this to be able to be a reference.

[h-vetinari]

clang/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cppm

7–8

That comment looks outdated...

[ChuanqiXu]

Nice to see you back to continue work on this! Due to this one is important. I would have tried to continue the work. The problem of the previous patch should be trivial.
Generally we would continue the work in the previous page. But it doesn't matter if we feel the new page is cleaner.
BTW, would you like to review my patches for modules? Your review opinion is really important. But you resigned from all my patches a couple weeks ago and I don't know the reason until now...

[iains]

clang/lib/AST/ItaniumMangle.cpp

1070

So we mangle symbols in 'M.P.Q:B" as _ZW1MW1PW1Qnn.......

That seems slightly odd given that '.' is not significant in a C++20 modules name?
perhaps a necessity given that one doe not know if the target can process periods in symbol names...

[urnathan]

clang/lib/AST/ItaniumMangle.cpp

481

The rest of the mangler prefers passing must-be-non-null pointers around, rather than use references. for instance:

void mangleTemplateParamDecl(const NamedDecl *Decl);
void mangleLambda(const CXXRecordDecl *Lambda);
void mangleNestedName(GlobalDecl GD, const DeclContext *DC,
                      const AbiTagList *AdditionalAbiTags,
                      bool NoFunction=false);

It seems more jarring to use a reference here -- particularly juggling between DeclContext ptr & reference.

WRT passing nullptr -- that's in the closure-prefix mangling

// A <closure-prefix> represents a variable or field, not a regular
// DeclContext, so needs special handling. In this case we're mangling a
// limited form of <nested-name>:

I suppose we could get the context out of the GD, but we know it is not relevant to the unqualified name mangling call, so seems like unnecessary work.

1070

Correct, we want mangled names to be alphanumeric, (and .suffix has also become a thing in mangled names). Treating each part separately allows us to have a substitution mechanism similar to the scope substitution mechanism already there.

(In case it wasn't clear, the earlier module mangling also had this property)

[urnathan]

rebase, fix stale test comment

[iains]

I have no further comments, this LGTM (and it would be nice to see it landed).
Have you WIP for the module initialiser mangling?

[urnathan]

In D122256#3410125, @iains wrote:

I have no further comments, this LGTM (and it would be nice to see it landed).
Have you WIP for the module initialiser mangling?

Yes. I have that ready to go as soon as there's a user.

[iains]

In D122256#3411150, @urnathan wrote:

In D122256#3410125, @iains wrote:

I have no further comments, this LGTM (and it would be nice to see it landed).
Have you WIP for the module initialiser mangling?

Yes. I have that ready to go as soon as there's a user.

I am actively working on module initialisers - so there's certainly soon to be a user (and having a patch to test my work on would be really helpful).

[dblaikie]

In D122256#3410125, @iains wrote:

I have no further comments, this LGTM (and it would be nice to see it landed).

Good enough for me. While I realize there's some missing continuity between a lot of the previous modules work (@rsmith) & the recent work - and I really don't have enough context to provide really very nuanced review (though I do try to follow along and happy to be included) - don't let that slow you folks down, If between you the direction seems reasonable, in the absence of any active concerns from elsewhere, you should feel empowered to approve each other's patches/press forward.

[MaskRay]

The differential has the same intention/subject as D118352. In such a case reusing the preexisting differential would have been better. I have left more comments on https://reviews.llvm.org/D125825#3522911

Note: a revert was committed (https://reviews.llvm.org/D118352#3368921) in 11 hours after the problem was reported.
It was fairly legitimate. The user pushing the revert helps maintain build bots green. (Some groups may be more aggressive, e.g. they may leave a comment and perform a revert in 10 minutes.
Technically that is also fine, but sometimes can be done better.)
In this particular case, I believe the problem was just a Mach-O platform differential that Mach-O IR output doesn't use dso_local . This is very common when adding new tests to test/clang/CodeGen* and contributors often neglect it.
If I had seen the failure in time, I would have tried fixing the test as it is quite straightforward, instead of reverting it.

(Thanks for adding #clang-language-wg since this was a patch that some folks would like to subscribe to.)

Additional notes: I'd add ( (@_ZW6ModuleE24noninline_module_linkagev( instead of @_ZW6ModuleE24noninline_module_linkagev) to check the full mangled name. The single character has very low overhead but makes the test stricter/more robust.

clang/lib/AST/Decl.cpp

NamedDecl::ExplicitVisibilityKind EK = usesTypeVisibility(D)
                                              : NamedDecl::VisibilityForValue;
   LVComputationKind CK(EK);
   return getLVForDecl(D, D->getASTContext().getLangOpts().IgnoreXCOFFVisibility
                              ? CK.forLinkageOnly()
                              : CK);
 }
 
 Module *Decl::getOwningModuleForLinkage(bool IgnoreLinkage) const {
+  if (isa<NamespaceDecl>(this))
+    // Namespaces never have module linkage.  It is the entities within them
+    // that [may] do.
+    return nullptr;
+
   Module *M = getOwningModule();
   if (!M)
     return nullptr;
 
   switch (M->Kind) {
   case Module::ModuleMapModule:
     // Module map modules have no special linkage semantics.
     return nullptr;

clang/lib/AST/ItaniumMangle.cpp

public:
   void mangleNumber(int64_t Number);
   void mangleFloat(const llvm::APFloat &F);
   void mangleFunctionEncoding(GlobalDecl GD);
   void mangleSeqID(unsigned SeqID);
   void mangleName(GlobalDecl GD);
   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(QualType T);
   bool mangleSubstitution(TemplateName Template);
   bool mangleSubstitution(uintptr_t Ptr);
 
void mangleUnresolvedName(NestedNameSpecifier *qualifier,
                             const TemplateArgumentLoc *TemplateArgs,
                             unsigned NumTemplateArgs,
                             unsigned KnownArity = UnknownArity);
 
   void mangleFunctionEncodingBareType(const FunctionDecl *FD);
 
   void mangleNameWithAbiTags(GlobalDecl GD,
                              const AbiTagList *AdditionalAbiTags);
-  void mangleModuleName(const Module *M);
-  void mangleModuleNamePrefix(StringRef Name);
+  void mangleModuleName(const NamedDecl *ND);
   void mangleTemplateName(const TemplateDecl *TD,
                           const TemplateArgument *TemplateArgs,
                           unsigned NumTemplateArgs);
-  void mangleUnqualifiedName(GlobalDecl GD,
+  void mangleUnqualifiedName(GlobalDecl GD, const DeclContext *DC,
                              const AbiTagList *AdditionalAbiTags) {
-    mangleUnqualifiedName(GD, cast<NamedDecl>(GD.getDecl())->getDeclName(), UnknownArity,
-                          AdditionalAbiTags);
+    mangleUnqualifiedName(GD, cast<NamedDecl>(GD.getDecl())->getDeclName(), DC,
+                          UnknownArity, AdditionalAbiTags);
   }
   void mangleUnqualifiedName(GlobalDecl GD, DeclarationName Name,
-                             unsigned KnownArity,
+                             const DeclContext *DC, unsigned KnownArity,
                              const AbiTagList *AdditionalAbiTags);
-  void mangleUnscopedName(GlobalDecl GD,
+  void mangleUnscopedName(GlobalDecl GD, const DeclContext *DC,
                           const AbiTagList *AdditionalAbiTags);
-  void mangleUnscopedTemplateName(GlobalDecl GD,
+  void mangleUnscopedTemplateName(GlobalDecl GD, const DeclContext *DC,
                                   const AbiTagList *AdditionalAbiTags);
   void mangleSourceName(const IdentifierInfo *II);
   void mangleRegCallName(const IdentifierInfo *II);
   void mangleDeviceStubName(const IdentifierInfo *II);
   void mangleSourceNameWithAbiTags(
       const NamedDecl *ND, const AbiTagList *AdditionalAbiTags = nullptr);
   void mangleLocalName(GlobalDecl GD,
                        const AbiTagList *AdditionalAbiTags);
if (const auto *VD = dyn_cast<VarDecl>(D)) {
     // Decompositions are mangled.
     if (isa<DecompositionDecl>(VD))
       return true;
 
     // C variables are not mangled.
     if (VD->isExternC())
       return false;
 
-    // Variables at global scope with non-internal linkage are not mangled.
+    // Variables at global scope are not mangled unless they have internal
+    // linkage or are specializations or are attached to a named module.
     const DeclContext *DC = getEffectiveDeclContext(D);
     // Check for extern variable declared locally.
     if (DC->isFunctionOrMethod() && D->hasLinkage())
       while (!DC->isFileContext())
         DC = getEffectiveParentContext(DC);
     if (DC->isTranslationUnit() && D->getFormalLinkage() != InternalLinkage &&
         !CXXNameMangler::shouldHaveAbiTags(*this, VD) &&
-        !isa<VarTemplateSpecializationDecl>(VD))
+        !isa<VarTemplateSpecializationDecl>(VD) &&
+        !VD->getOwningModuleForLinkage())
       return false;
   }
 
   return true;
 }
 
 void CXXNameMangler::writeAbiTags(const NamedDecl *ND,
                                   const AbiTagList *AdditionalAbiTags) {
void CXXNameMangler::mangleNameWithAbiTags(GlobalDecl GD,
 
   assert(!isa<LinkageSpecDecl>(DC) && "context cannot be LinkageSpecDecl");
 
   if (isLocalContainerContext(DC)) {
     mangleLocalName(GD, AdditionalAbiTags);
     return;
   }
 
-  // Do not mangle the owning module for an external linkage declaration.
-  // This enables backwards-compatibility with non-modular code, and is
-  // a valid choice since conflicts are not permitted by C++ Modules TS
-  // [basic.def.odr]/6.2.
-  if (!ND->hasExternalFormalLinkage())
-    if (Module *M = ND->getOwningModuleForLinkage())
-      mangleModuleName(M);
-
   // Closures can require a nested-name mangling even if they're semantically
   // in the global namespace.
   if (const NamedDecl *PrefixND = getClosurePrefix(ND)) {
     mangleNestedNameWithClosurePrefix(GD, PrefixND, AdditionalAbiTags);
     return;
   }
 
   if (DC->isTranslationUnit() || isStdNamespace(DC)) {
     // Check if we have a template.
     const TemplateArgumentList *TemplateArgs = nullptr;
     if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
-      mangleUnscopedTemplateName(TD, AdditionalAbiTags);
+      mangleUnscopedTemplateName(TD, DC, AdditionalAbiTags);
       mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
       return;
     }
 
-    mangleUnscopedName(GD, AdditionalAbiTags);
+    mangleUnscopedName(GD, DC, AdditionalAbiTags);
     return;
   }
 
   mangleNestedName(GD, DC, AdditionalAbiTags);
 }
 
-void CXXNameMangler::mangleModuleName(const Module *M) {
-  // Implement the C++ Modules TS name mangling proposal; see
-  //     https://gcc.gnu.org/wiki/cxx-modules?action=AttachFile
-  //
-  //   <module-name> ::= W <unscoped-name>+ E
-  //                 ::= W <module-subst> <unscoped-name>* E
-  Out << 'W';
-  mangleModuleNamePrefix(M->Name);
-  Out << 'E';
+void CXXNameMangler::mangleModuleName(const NamedDecl *ND) {
+  if (ND->isExternallyVisible())
+    if (Module *M = ND->getOwningModuleForLinkage())
+      mangleModuleNamePrefix(M->getPrimaryModuleInterfaceName());
 }
 
+// <module-name> ::= <module-subname>
+//     ::= <module-name> <module-subname>
+//     ::= <substitution>
+// <module-subname> ::= W <source-name>
+//        ::= W P <source-name> # not (yet) needed
 void CXXNameMangler::mangleModuleNamePrefix(StringRef Name) {
-  //  <module-subst> ::= _ <seq-id>          # 0 < seq-id < 10
-  //                 ::= W <seq-id - 10> _   # otherwise
+  //  <substitution> ::= S <seq-id> _
   auto It = ModuleSubstitutions.find(Name);
   if (It != ModuleSubstitutions.end()) {
-    if (It->second < 10)
-      Out << '_' << static_cast<char>('0' + It->second);
-    else
-      Out << 'W' << (It->second - 10) << '_';
+    Out << 'S';
+    mangleSeqID(It->second);
     return;
   }
 
   // FIXME: Preserve hierarchy in module names rather than flattening
   // them to strings; use Module*s as substitution keys.
   auto Parts = Name.rsplit('.');
   if (Parts.second.empty())
     Parts.second = Parts.first;
   else
     mangleModuleNamePrefix(Parts.first);
 
+  Out << 'W';
   Out << Parts.second.size() << Parts.second;
-  ModuleSubstitutions.insert({Name, ModuleSubstitutions.size()});
+  ModuleSubstitutions.insert({Name, SeqID++});
 }
 
 void CXXNameMangler::mangleTemplateName(const TemplateDecl *TD,
                                         const TemplateArgument *TemplateArgs,
                                         unsigned NumTemplateArgs) {
   const DeclContext *DC = Context.getEffectiveDeclContext(TD);
 
   if (DC->isTranslationUnit() || isStdNamespace(DC)) {
-    mangleUnscopedTemplateName(TD, nullptr);
+    mangleUnscopedTemplateName(TD, DC, nullptr);
     mangleTemplateArgs(asTemplateName(TD), TemplateArgs, NumTemplateArgs);
   } else {
     mangleNestedName(TD, TemplateArgs, NumTemplateArgs);
   }
 }
 
-void CXXNameMangler::mangleUnscopedName(GlobalDecl GD,
+void CXXNameMangler::mangleUnscopedName(GlobalDecl GD, const DeclContext *DC,
                                         const AbiTagList *AdditionalAbiTags) {
-  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
   //  <unscoped-name> ::= <unqualified-name>
   //                  ::= St <unqualified-name>   # ::std::
 
-  if (isStdNamespace(Context.getEffectiveDeclContext(ND)))
+  assert(!isa<LinkageSpecDecl>(DC) && "unskipped LinkageSpecDecl");
+  if (isStdNamespace(DC))
     Out << "St";
 
-  mangleUnqualifiedName(GD, AdditionalAbiTags);
+  mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
 }
 
 void CXXNameMangler::mangleUnscopedTemplateName(
-    GlobalDecl GD, const AbiTagList *AdditionalAbiTags) {
+    GlobalDecl GD, const DeclContext *DC, const AbiTagList *AdditionalAbiTags) {
   const TemplateDecl *ND = cast<TemplateDecl>(GD.getDecl());
   //     <unscoped-template-name> ::= <unscoped-name>
   //                              ::= <substitution>
   if (mangleSubstitution(ND))
     return;
 
   // <template-template-param> ::= <template-param>
   if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
     assert(!AdditionalAbiTags &&
            "template template param cannot have abi tags");
     mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
   } else if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND)) {
-    mangleUnscopedName(GD, AdditionalAbiTags);
+    mangleUnscopedName(GD, DC, AdditionalAbiTags);
   } else {
-    mangleUnscopedName(GD.getWithDecl(ND->getTemplatedDecl()), AdditionalAbiTags);
+    mangleUnscopedName(GD.getWithDecl(ND->getTemplatedDecl()), DC,
+                       AdditionalAbiTags);
   }
 
   addSubstitution(ND);
 }
 
 void CXXNameMangler::mangleFloat(const llvm::APFloat &f) {
   // ABI:
   //   Floating-point literals are encoded using a fixed-length
void CXXNameMangler::mangleUnresolvedName(
   }
 
   // The <simple-id> and on <operator-name> productions end in an optional
   // <template-args>.
   if (TemplateArgs)
     mangleTemplateArgs(TemplateName(), TemplateArgs, NumTemplateArgs);
 }
 
-void CXXNameMangler::mangleUnqualifiedName(GlobalDecl GD,
-                                           DeclarationName Name,
-                                           unsigned KnownArity,
-                                           const AbiTagList *AdditionalAbiTags) {
+void CXXNameMangler::mangleUnqualifiedName(
+    GlobalDecl GD, DeclarationName Name, const DeclContext *DC,
+    unsigned KnownArity, const AbiTagList *AdditionalAbiTags) {
   const NamedDecl *ND = cast_or_null<NamedDecl>(GD.getDecl());
-  unsigned Arity = KnownArity;
-  //  <unqualified-name> ::= <operator-name>
+  //  <unqualified-name> ::= [<module-name>] <operator-name>
   //                     ::= <ctor-dtor-name>
-  //                     ::= <source-name>
+  //                     ::= [<module-name>] <source-name>
+  //                     ::= [<module-name>] DC <source-name>* E
+
+  if (ND && DC && DC->isFileContext())
+    mangleModuleName(ND);
+
+  unsigned Arity = KnownArity;
   switch (Name.getNameKind()) {
   case DeclarationName::Identifier: {
     const IdentifierInfo *II = Name.getAsIdentifierInfo();
 
     // We mangle decomposition declarations as the names of their bindings.
     if (auto *DD = dyn_cast<DecompositionDecl>(ND)) {
       // FIXME: Non-standard mangling for decomposition declarations:
       //
       //  <unqualified-name> ::= DC <source-name>* E
       //
-      // These can never be referenced across translation units, so we do
-      // not need a cross-vendor mangling for anything other than demanglers.
       // Proposed on cxx-abi-dev on 2016-08-12
       Out << "DC";
       for (auto *BD : DD->bindings())
         mangleSourceName(BD->getDeclName().getAsIdentifierInfo());
       Out << 'E';
       writeAbiTags(ND, AdditionalAbiTags);
       break;
     }
void CXXNameMangler::mangleNestedName(GlobalDecl GD,
 
   // Check if we have a template.
   const TemplateArgumentList *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
     mangleTemplatePrefix(TD, NoFunction);
     mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
   } else {
     manglePrefix(DC, NoFunction);
-    mangleUnqualifiedName(GD, AdditionalAbiTags);
+    mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
   }
 
   Out << 'E';
 }
 void CXXNameMangler::mangleNestedName(const TemplateDecl *TD,
                                       const TemplateArgument *TemplateArgs,
                                       unsigned NumTemplateArgs) {
   // <nested-name> ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
void CXXNameMangler::mangleNestedNameWithClosurePrefix(
   // DeclContext, so needs special handling. In this case we're mangling a
   // limited form of <nested-name>:
   //
   // <nested-name> ::= N <closure-prefix> <closure-type-name> E
 
   Out << 'N';
 
   mangleClosurePrefix(PrefixND);
-  mangleUnqualifiedName(GD, AdditionalAbiTags);
+  mangleUnqualifiedName(GD, nullptr, AdditionalAbiTags);
 
   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 (CXXRD && CXXRD->isLambda()) {
           Out << '_';
         }
       }
     }
 
     // Mangle the name relative to the closest enclosing function.
     // equality ok because RD derived from ND above
     if (D == RD)  {
-      mangleUnqualifiedName(RD, AdditionalAbiTags);
+      mangleUnqualifiedName(RD, DC, AdditionalAbiTags);
     } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
       if (const NamedDecl *PrefixND = getClosurePrefix(BD))
         mangleClosurePrefix(PrefixND, true /*NoFunction*/);
       else
         manglePrefix(Context.getEffectiveDeclContext(BD), true /*NoFunction*/);
       assert(!AdditionalAbiTags && "Block cannot have additional abi tags");
       mangleUnqualifiedBlock(BD);
     } else {
if (const ParmVarDecl *Parm
           mangleNumber(Num - 2);
         Out << '_';
       }
     }
 
     assert(!AdditionalAbiTags && "Block cannot have additional abi tags");
     mangleUnqualifiedBlock(BD);
   } else {
-    mangleUnqualifiedName(GD, AdditionalAbiTags);
+    mangleUnqualifiedName(GD, DC, AdditionalAbiTags);
   }
 
   if (const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) {
     unsigned disc;
     if (Context.getNextDiscriminator(ND, disc)) {
       if (disc < 10)
         Out << '_' << disc;
       else
void CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) {
 
   // Check if we have a template-prefix or a closure-prefix.
   const TemplateArgumentList *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(ND, TemplateArgs)) {
     mangleTemplatePrefix(TD);
     mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
   } else if (const NamedDecl *PrefixND = getClosurePrefix(ND)) {
     mangleClosurePrefix(PrefixND, NoFunction);
-    mangleUnqualifiedName(ND, nullptr);
+    mangleUnqualifiedName(ND, nullptr, nullptr);
   } else {
-    manglePrefix(Context.getEffectiveDeclContext(ND), NoFunction);
-    mangleUnqualifiedName(ND, nullptr);
+    const DeclContext *DC = Context.getEffectiveDeclContext(ND);
+    manglePrefix(DC, NoFunction);
+    mangleUnqualifiedName(ND, DC, nullptr);
   }
 
   addSubstitution(ND);
 }
 
 void CXXNameMangler::mangleTemplatePrefix(TemplateName Template) {
   // <template-prefix> ::= <prefix> <template unqualified-name>
   //                   ::= <template-param>
void CXXNameMangler::mangleTemplatePrefix(GlobalDecl GD,
 
   if (mangleSubstitution(ND))
     return;
 
   // <template-template-param> ::= <template-param>
   if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
     mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
   } else {
-    manglePrefix(Context.getEffectiveDeclContext(ND), NoFunction);
+    const DeclContext *DC = Context.getEffectiveDeclContext(ND);
+    manglePrefix(DC, NoFunction);
     if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND))
-      mangleUnqualifiedName(GD, nullptr);
+      mangleUnqualifiedName(GD, DC, nullptr);
     else
-      mangleUnqualifiedName(GD.getWithDecl(ND->getTemplatedDecl()), nullptr);
+      mangleUnqualifiedName(GD.getWithDecl(ND->getTemplatedDecl()), DC,
+                            nullptr);
   }
 
   addSubstitution(ND);
 }
 
 const NamedDecl *CXXNameMangler::getClosurePrefix(const Decl *ND) {
   if (getASTContext().getLangOpts().getClangABICompat() <=
       LangOptions::ClangABI::Ver12)
void CXXNameMangler::mangleClosurePrefix(const NamedDecl *ND, bool NoFunction) {
   if (mangleSubstitution(ND))
     return;
 
   const TemplateArgumentList *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(ND, TemplateArgs)) {
     mangleTemplatePrefix(TD, NoFunction);
     mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
   } else {
-    manglePrefix(Context.getEffectiveDeclContext(ND), NoFunction);
-    mangleUnqualifiedName(ND, nullptr);
+    const auto *DC = Context.getEffectiveDeclContext(ND);
+    manglePrefix(DC, NoFunction);
+    mangleUnqualifiedName(ND, DC, nullptr);
   }
 
   Out << 'M';
 
   addSubstitution(ND);
 }
 
 /// Mangles a template name under the production <type>.  Required for
bool CXXNameMangler::isSpecializedAs(QualType S, llvm::StringRef Name,
 
   const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
   if (TemplateArgs.size() != 1)
     return false;
 
   if (TemplateArgs[0].getAsType() != A)
     return false;
 
+  if (SD->getSpecializedTemplate()->getOwningModuleForLinkage())
+    return false;
+
   return true;
 }
 
 /// Returns whether SD is a template specialization std::Name<char,
 /// std::char_traits<char> [, std::allocator<char>]>
 /// HasAllocator controls whether the 3rd template argument is needed.
 bool CXXNameMangler::isStdCharSpecialization(
     const ClassTemplateSpecializationDecl *SD, llvm::StringRef Name,
bool CXXNameMangler::isStdCharSpecialization(
 
   if (!isSpecializedAs(TemplateArgs[1].getAsType(), "char_traits", A))
     return false;
 
   if (HasAllocator &&
       !isSpecializedAs(TemplateArgs[2].getAsType(), "allocator", A))
     return false;
 
+  if (SD->getSpecializedTemplate()->getOwningModuleForLinkage())
+    return false;
+
   return true;
 }
 
 bool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) {
   // <substitution> ::= St # ::std::
   if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
     if (isStd(NS)) {
       Out << "St";
       return true;
     }
     return false;
   }
 
   if (const ClassTemplateDecl *TD = dyn_cast<ClassTemplateDecl>(ND)) {
     if (!isStdNamespace(Context.getEffectiveDeclContext(TD)))
       return false;
 
+    if (TD->getOwningModuleForLinkage())
+      return false;
+
     // <substitution> ::= Sa # ::std::allocator
     if (TD->getIdentifier()->isStr("allocator")) {
       Out << "Sa";
       return true;
     }
 
     // <<substitution> ::= Sb # ::std::basic_string
     if (TD->getIdentifier()->isStr("basic_string")) {
       Out << "Sb";
       return true;
     }
     return false;
   }
 
   if (const ClassTemplateSpecializationDecl *SD =
         dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
     if (!isStdNamespace(Context.getEffectiveDeclContext(SD)))
       return false;
 
+    if (SD->getSpecializedTemplate()->getOwningModuleForLinkage())
+      return false;
+
     //    <substitution> ::= Ss # ::std::basic_string<char,
     //                            ::std::char_traits<char>,
     //                            ::std::allocator<char> >
     if (isStdCharSpecialization(SD, "basic_string", /*HasAllocator=*/true)) {
       Out << "Ss";
       return true;
     }
 

clang/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cpp

 // RUN: %clang_cc1 -fmodules-ts %S/module.cppm -triple %itanium_abi_triple -emit-module-interface -o %t
 // RUN: %clang_cc1 -fmodules-ts %s -triple %itanium_abi_triple -fmodule-file=%t -emit-llvm -o - | FileCheck %s --implicit-check-not=unused --implicit-check-not=global_module
 
-// CHECK-DAG: @extern_var_exported = external {{(dso_local )?}}global
-// CHECK-DAG: @inline_var_exported = linkonce_odr {{(dso_local )?}}global
-// CHECK-DAG: @const_var_exported = available_externally {{(dso_local )?}}constant i32 3,
+// CHECK-DAG: @_ZW6Module19extern_var_exported = external {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module19inline_var_exported = linkonce_odr {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module18const_var_exported = available_externally {{(dso_local )?}}constant i32 3,
 //
-// CHECK-DAG: @_ZW6ModuleE25extern_var_module_linkage = external {{(dso_local )?}}global
-// CHECK-DAG: @_ZW6ModuleE25inline_var_module_linkage = linkonce_odr {{(dso_local )?}}global
-// CHECK-DAG: @_ZW6ModuleE25static_var_module_linkage = available_externally {{(dso_local )?}}global i32 0,
-// CHECK-DAG: @_ZW6ModuleE24const_var_module_linkage = available_externally {{(dso_local )?}}constant i32 3,
+// CHECK-DAG: @_ZW6Module25extern_var_module_linkage = external {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module25inline_var_module_linkage = linkonce_odr {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module25static_var_module_linkage = available_externally {{(dso_local )?}}global i32 0,
+// CHECK-DAG: @_ZW6Module24const_var_module_linkage = available_externally {{(dso_local )?}}constant i32 3,
 
 module Module;
 
 void use() {
-  // CHECK: define linkonce_odr {{.*}}@_Z20used_inline_exportedv
+  // CHECK: define linkonce_odr {{.*}}@_ZW6Module20used_inline_exportedv
   used_inline_exported();
-  // CHECK: declare {{.*}}@_Z18noninline_exportedv
+  // CHECK: declare {{.*}}@_ZW6Module18noninline_exportedv
   noninline_exported();
 
   (void)&extern_var_exported;
   (void)&inline_var_exported;
   (void)&const_var_exported;
 
   // FIXME: This symbol should not be visible here.
-  // CHECK: declare {{.*}}@_ZW6ModuleE26used_static_module_linkagev
+  // CHECK: declare {{.*}}@_ZW6Module26used_static_module_linkagev
   used_static_module_linkage();
 
-  // CHECK: define linkonce_odr {{.*}}@_ZW6ModuleE26used_inline_module_linkagev
+  // CHECK: define linkonce_odr {{.*}}@_ZW6Module26used_inline_module_linkagev
   used_inline_module_linkage();
 
-  // CHECK: declare {{.*}}@_ZW6ModuleE24noninline_module_linkagev
+  // CHECK: declare {{.*}}@_ZW6Module24noninline_module_linkagev
   noninline_module_linkage();
 
   (void)&extern_var_module_linkage;
   (void)&inline_var_module_linkage;
   (void)&static_var_module_linkage; // FIXME: Should not be visible here.
   (void)&const_var_module_linkage;
 }

clang/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cppm

 // RUN: %clang_cc1 -fmodules-ts %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s --implicit-check-not unused_inline --implicit-check-not unused_stastic_global_module
 
 // CHECK-DAG: @extern_var_global_module = external {{(dso_local )?}}global
 // CHECK-DAG: @inline_var_global_module = linkonce_odr {{(dso_local )?}}global
 // CHECK-DAG: @_ZL24static_var_global_module = internal global
 // CHECK-DAG: @_ZL23const_var_global_module = internal constant
 //
-// For ABI compatibility, these symbols do not include the module name.
-// CHECK-DAG: @extern_var_exported = external {{(dso_local )?}}global
+// With strong-ownership, the module is mangled into exported symbols
+// that are attached to a named module.
+// CHECK-DAG: @_ZW6Module19extern_var_exported = external {{(dso_local )?}}global
 // FIXME: Should this be 'weak_odr global'? Presumably it must be, since we
 // can discard this global and its initializer (if any), and other TUs are not
 // permitted to run the initializer for this variable.
-// CHECK-DAG: @inline_var_exported = linkonce_odr {{(dso_local )?}}global
-// CHECK-DAG: @const_var_exported = {{(dso_local )?}}constant
+// CHECK-DAG: @_ZW6Module19inline_var_exported = linkonce_odr {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module18const_var_exported = {{(dso_local )?}}constant
 //
-// CHECK-DAG: @_ZW6ModuleE25extern_var_module_linkage = external {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module25extern_var_module_linkage = external {{(dso_local )?}}global
 // FIXME: Should this be 'weak_odr global'? Presumably it must be, since we
 // can discard this global and its initializer (if any), and other TUs are not
 // permitted to run the initializer for this variable.
-// CHECK-DAG: @_ZW6ModuleE25inline_var_module_linkage = linkonce_odr {{(dso_local )?}}global
-// CHECK-DAG: @_ZW6ModuleE25static_var_module_linkage = {{(dso_local )?}}global
-// CHECK-DAG: @_ZW6ModuleE24const_var_module_linkage = {{(dso_local )?}}constant
+// CHECK-DAG: @_ZW6Module25inline_var_module_linkage = linkonce_odr {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module25static_var_module_linkage = {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module24const_var_module_linkage = {{(dso_local )?}}constant
 //
-// CHECK-DAG: @_ZW6ModuleE25unused_var_module_linkage = {{(dso_local )?}}global i32 4
-// CHECK-DAG: @_ZW6ModuleE32unused_static_var_module_linkage = {{(dso_local )?}}global i32 5
-// CHECK-DAG: @_ZW6ModuleE31unused_const_var_module_linkage = {{(dso_local )?}}constant i32 7
+// CHECK-DAG: @_ZW6Module25unused_var_module_linkage = {{(dso_local )?}}global i32 4
+// CHECK-DAG: @_ZW6Module32unused_static_var_module_linkage = {{(dso_local )?}}global i32 5
+// CHECK-DAG: @_ZW6Module31unused_const_var_module_linkage = {{(dso_local )?}}constant i32 7
 
 static void unused_static_global_module() {}
 static void used_static_global_module() {}
 
 inline void unused_inline_global_module() {}
 inline void used_inline_global_module() {}
 
 extern int extern_var_global_module;

 export {
   inline void unused_inline_exported() {}
   inline void used_inline_exported() {}
 
   extern int extern_var_exported;
   inline int inline_var_exported;
   const int const_var_exported = 3;
 
-  // CHECK: define {{(dso_local )?}}void {{.*}}@_Z18noninline_exportedv
+  // CHECK: define {{(dso_local )?}}void {{.*}}@_ZW6Module18noninline_exportedv
   void noninline_exported() {
     (void)&extern_var_exported;
     (void)&inline_var_exported;
     (void)&const_var_exported;
   }
 }
 
 // FIXME: Ideally we wouldn't emit this as its name is not visible outside this
 // TU, but this module interface might contain a template that can use this
 // function so we conservatively emit it for now.
-// CHECK: define {{(dso_local )?}}void {{.*}}@_ZW6ModuleE28unused_static_module_linkagev
+// CHECK: define {{(dso_local )?}}void {{.*}}@_ZW6Module28unused_static_module_linkagev
 static void unused_static_module_linkage() {}
-// CHECK: define {{(dso_local )?}}void {{.*}}@_ZW6ModuleE26used_static_module_linkagev
+// CHECK: define {{(dso_local )?}}void {{.*}}@_ZW6Module26used_static_module_linkagev
 static void used_static_module_linkage() {}
 
 inline void unused_inline_module_linkage() {}
 inline void used_inline_module_linkage() {}
 
 extern int extern_var_module_linkage;
 inline int inline_var_module_linkage;
 static int static_var_module_linkage;
 const int const_var_module_linkage = 3;
 
-// CHECK: define {{(dso_local )?}}void {{.*}}@_ZW6ModuleE24noninline_module_linkagev
+// CHECK: define {{(dso_local )?}}void {{.*}}@_ZW6Module24noninline_module_linkagev
 void noninline_module_linkage() {
   used_static_module_linkage();
-  // CHECK: define linkonce_odr {{.*}}@_ZW6ModuleE26used_inline_module_linkagev
+  // CHECK: define linkonce_odr {{.*}}@_ZW6Module26used_inline_module_linkagev
   used_inline_module_linkage();
 
   (void)&extern_var_module_linkage;
   (void)&inline_var_module_linkage;
   (void)&static_var_module_linkage;
   (void)&const_var_module_linkage;
 }
 
 int unused_var_module_linkage = 4;
 static int unused_static_var_module_linkage = 5;
 inline int unused_inline_var_module_linkage = 6;
 const int unused_const_var_module_linkage = 7;
 
 struct a {
   struct b {};
   struct c {};
 };
-// CHECK: define {{(dso_local )?}}void @_ZW6ModuleE1fW_0EN1a1bEW_0ENS_1cE(
+// CHECK: define {{(dso_local )?}}void @_ZW6Module1fNS_1a1bENS0_1cE(
 void f(a::b, a::c) {}

clang/test/CXX/modules-ts/basic/basic.def.odr/p4/user.cpp

 // RUN: %clang_cc1 -fmodules-ts %S/module.cppm -triple %itanium_abi_triple -emit-module-interface -o %t
 // RUN: %clang_cc1 -fmodules-ts %s -triple %itanium_abi_triple -fmodule-file=%t -emit-llvm -o - | FileCheck %s --implicit-check-not=unused --implicit-check-not=global_module
 
-// CHECK-DAG: @extern_var_exported = external {{(dso_local )?}}global
-// CHECK-DAG: @inline_var_exported = linkonce_odr {{(dso_local )?}}global
-// CHECK-DAG: @const_var_exported = available_externally {{(dso_local )?}}constant i32 3
+// CHECK-DAG: @_ZW6Module19extern_var_exported = external {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module19inline_var_exported = linkonce_odr {{(dso_local )?}}global
+// CHECK-DAG: @_ZW6Module18const_var_exported = available_externally {{(dso_local )?}}constant i32 3
 
 import Module;
 
 void use() {
-  // CHECK: define linkonce_odr {{.*}}@_Z20used_inline_exportedv
+  // CHECK: define linkonce_odr {{.*}}@_ZW6Module20used_inline_exportedv
   used_inline_exported();
-  // CHECK: declare {{.*}}@_Z18noninline_exportedv
+  // CHECK: declare {{.*}}@_ZW6Module18noninline_exportedv
   noninline_exported();
 
   (void)&extern_var_exported;
   (void)&inline_var_exported;
   (void)&const_var_exported;
 
   // Module-linkage declarations are not visible here.
 }

clang/test/CXX/modules-ts/basic/basic.link/p3.cppm

 // RUN: %clang_cc1 -fmodules-ts -triple x86_64-linux %s -emit-module-interface -o %t
 // RUN: %clang_cc1 -fmodules-ts -triple x86_64-linux -x pcm %t -emit-llvm -o - | FileCheck %s
 
 export module M;
 
-// CHECK-DAG: @_ZW1ME1a ={{.*}} constant i32 1
+// CHECK-DAG: @_ZW1M1a ={{.*}} constant i32 1
 const int a = 1;
-// CHECK-DAG: @b ={{.*}} constant i32 2
+// CHECK-DAG: @_ZW1M1b ={{.*}} constant i32 2
 export const int b = 2;
 
 export int f() { return a + b; }

clang/test/CXX/modules-ts/codegen-basics.cppm

 // RUN: %clang_cc1 -fmodules-ts -std=c++1z -triple=x86_64-linux-gnu -fmodules-codegen -emit-module-interface %s -o %t.pcm
 // RUN: %clang_cc1 -fmodules-ts -std=c++1z -triple=x86_64-linux-gnu %t.pcm -emit-llvm -o - | FileCheck %s
 
 export module FooBar;
 
 export {
-  // CHECK-DAG: define{{.*}} i32 @_Z1fv(
+  // CHECK-DAG: define{{.*}} i32 @_ZW6FooBar1fv(
   int f() { return 0; }
 }
 
-// CHECK-DAG: define weak_odr void @_ZW6FooBarE2f2v(
+// CHECK-DAG: define weak_odr void @_ZW6FooBar2f2v(
 inline void f2() {}
 
-// CHECK-DAG: define{{.*}} void @_ZW6FooBarE2f3v(
+// CHECK-DAG: define{{.*}} void @_ZW6FooBar2f3v(
 static void f3() {}
 export void use_f3() { f3(); }
 
 // FIXME: Emit global variables and their initializers with this TU.
 // Emit an initialization function that other TUs can call, with guard variable?
 
 // FIXME: const-qualified variables don't have implicit internal linkage when owned by a module.

clang/test/CodeGenCXX/Inputs/cxx20-module-impl-1a.cpp

+export module Foo;
+export void Exported();
+void Module();

clang/test/CodeGenCXX/Inputs/cxx20-module-std-subst-2a.cpp

+module;
+# 5 __FILE__ 1
+namespace std {
+template <typename A> struct allocator {};
+template <typename C, typename T, typename A>
+class basic_string;
+} // namespace std
+# 12 "" 2
+export module RenameString;
+export template <typename C, typename T>
+using str = std::basic_string<C, T, std::allocator<C>>;

clang/test/CodeGenCXX/cxx20-module-decomp-1.cpp

+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+
+export module Foo;
+
+// CHECK-DAG: @_ZW3Foo3ary =
+int ary[2];
+
+// CHECK-DAG: @_ZW3FooDC1a1bE =
+export auto &[a, b] = ary;
+
+namespace N {
+// CHECK-DAG: @_ZN1NW3FooDC1a1bEE =
+export auto &[a, b] = ary;
+// CHECK-DAG: @_ZN1NW3FooDC1c1dEE =
+auto &[c, d] = ary;
+// FIXME: We mangle the module name here, as we give this ModuleInternalLinkage
+// That's no longer needed.
+// CHECK DAG: @_ZN1MDC1e1fEE =
+static auto &__attribute__((used))[e, f] = ary;
+} // namespace N

clang/test/CodeGenCXX/cxx20-module-extern-1.cppm

+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+
+// module-purview extern "C++" semantics not implemented
+// XFAIL: *
+
+export module FOO;
+extern "C++" export class A;
+export class B;
+
+// CHECK-DAG: void @_ZW3FOO3FooP1APNS_1B(
+export void Foo (A *, B*) {
+}
+
+extern "C++" {
+// CHECK-DAG: void @_Z3BarP1APW3FOO1B(
+export void Bar (A *, B*) {
+}
+}

clang/test/CodeGenCXX/cxx20-module-impl-1a.cpp

+// RUN: %clang_cc1 -std=c++20 %S/Inputs/cxx20-module-impl-1a.cpp -triple %itanium_abi_triple -emit-module-interface -o %t
+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -fmodule-file=%t -emit-llvm -o - | FileCheck %s
+
+module Foo;
+
+// CHECK-DAG: @_ZW3Foo8Exportedv(
+void Exported() {
+}
+
+// CHECK-DAG: @_ZW3Foo6Modulev(
+void Module() {
+}
+
+// CHECK-DAG: @_ZW3Foo7Module2v(
+void Module2() {
+}

clang/test/CodeGenCXX/cxx20-module-nested-1.cppm

+// RUN: %clang_cc1 -std=c++20 -fmodules-ts %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+module;
+# 4 __FILE__ 1
+namespace Outer::Inner {
+class X;
+// CHECK-DAG: void @_ZN5Outer5Inner3BarERNS0_1XE(
+void Bar (X &) {}
+} // namespace Outer::Inner
+# 10 "" 2
+export module FOO;  
+namespace Outer {
+class Y;
+namespace Inner {
+// CHECK-DAG: void @_ZN5Outer5InnerW3FOO2FnERNS0_1XERNS_S1_1YE(
+void Fn (X &, Y &){}  // #1
+} // namespace Inner
+} // namespace Outer

clang/test/CodeGenCXX/cxx20-module-nested-2.cppm

+// RUN: %clang_cc1 -fmodules-ts %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+export module FOO;
+namespace Outer {
+class Y;
+class Inner {
+  class X;
+  void Fn (X &, Y &); // #2
+};
+// CHECK-DAG: void @_ZN5OuterW3FOO5Inner2FnERNS1_1XERNS_S0_1YE(
+void Inner::Fn (X &, Y &) {}
+}
+

clang/test/CodeGenCXX/cxx20-module-part-1a.cpp

+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+export module Foo:inter;
+
+// CHECK-DAG: @_ZW3Foo4Frobv(
+export void Frob() {
+}

clang/test/CodeGenCXX/cxx20-module-part-1b.cpp

+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+export module Foo:impl;
+
+// CHECK-DAG: @_ZW3Foo4Quuxv(
+export void Quux() {
+}

clang/test/CodeGenCXX/cxx20-module-part-1c.cpp

+// RUN: %clang_cc1 -std=c++20 %S/cxx20-module-part-1a.cpp -triple %itanium_abi_triple -emit-module-interface -o %t-inter
+// RUN: %clang_cc1 -std=c++20 %S/cxx20-module-part-1b.cpp -triple %itanium_abi_triple -emit-module-interface -o %t-impl
+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -fmodule-file=Foo:inter=%t-inter -fmodule-file=Foo:impl=%t-impl -emit-llvm -o - | FileCheck %s
+export module Foo;
+export import :inter;
+import :impl;
+
+void Wrap() {
+  // CHECK: call void @_ZW3Foo4Frobv()
+  Frob();
+  // CHECK: call void @_ZW3Foo4Quuxv()
+  Quux();
+}

clang/test/CodeGenCXX/cxx20-module-std-subst-1.cppm

+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+
+module;
+# 5 __FILE__ 1
+class Pooh;
+class Piglet;
+# 8 "" 2
+
+export module std; // might happen, you can't say it won't!
+
+namespace std {
+export template<typename T> class allocator {
+// just for testing, not real!
+void M (T *);
+template <typename U> U *N (T *);
+};
+
+template<typename T> void allocator<T>::M (T *) {}
+template<typename T> template<typename U> U *allocator<T>::N (T *) {
+return nullptr;
+}
+
+// CHECK-DAG: void @_ZNStW3std9allocatorIiE1MEPi(
+template void allocator<int>::M (int *);
+// CHECK-DAG: @_ZNStW3std9allocatorIiE1NIfEEPT_Pi(
+template float *allocator<int>::N<float> (int *);
+}
+
+// CHECK-DAG: @_ZNStW3std9allocatorI4PoohE1MEPS1_(
+template void std::allocator<Pooh>::M (Pooh *);
+// CHECK-DAG: @_ZNStW3std9allocatorI4PoohE1NI6PigletEEPT_PS1_(
+template Piglet *std::allocator<Pooh>::N<Piglet> (Pooh *);

clang/test/CodeGenCXX/cxx20-module-std-subst-2b.cpp

+// RUN: %clang_cc1 -std=c++20 %S/Inputs/cxx20-module-std-subst-2a.cpp -triple %itanium_abi_triple -emit-module-interface -o %t
+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -fmodule-file=%t -emit-llvm -o - | FileCheck %s
+
+export module Foo;
+import RenameString;
+
+namespace std {
+template <typename T> struct char_traits {};
+} // namespace std
+
+// use Sb mangling, not Ss as this is not global-module std::char_traits
+// std::char_traits.
+// CHECK-DAG: void @_ZW3Foo1fRSbIcStS_11char_traitsIcESaIcEE(
+void f(str<char, std::char_traits<char>> &s) {
+}

clang/test/CodeGenCXX/cxx20-module-std-subst-2c.cpp

+// RUN: %clang_cc1 -std=c++20 %S/Inputs/cxx20-module-std-subst-2a.cpp -triple %itanium_abi_triple -emit-module-interface -o %t
+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -fmodule-file=%t -emit-llvm -o - | FileCheck %s
+module;
+# 5 __FILE__ 1
+namespace std {
+template <typename A> struct char_traits {};
+} // namespace std
+# 9 "" 2
+export module Bar;
+import RenameString;
+
+// Use Ss as this is global-module std::char_traits
+// CHECK-DAG: void @_ZW3Bar1gRSs(
+void g(str<char, std::char_traits<char>> &s) {
+}

clang/test/CodeGenCXX/cxx20-module-sub-1a.cppm

+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+
+export module FOO.BAR;
+export class A;
+namespace Bob {
+export class B;
+
+// CHECK-DAG: void @_ZN3BobW3FOOW3BAR3BarEPS1_1APNS_S1_1BE(
+export void Bar (A *, B*) {
+}
+}
+
+// CHECK-DAG: void @_ZW3FOOW3BAR3FooPS0_1APN3BobS0_1BE(
+export void Foo (A *, Bob::B*) {
+}

clang/test/CodeGenCXX/cxx20-module-sub-1b.cppm

+// RUN: %clang_cc1 -std=c++20 %S/cxx20-module-sub-1a.cppm -triple %itanium_abi_triple -emit-module-interface -o %t
+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -fmodule-file=%t -emit-llvm -o - | FileCheck %s
+
+export module FOO.BAZ;
+import FOO.BAR;
+
+namespace Bob {
+
+// CHECK-DAG: void @_ZN3BobW3FOOW3BAZ3FooEPS0_W3BAR1APNS_S2_1BE(
+void Foo (A *, B*) {
+}
+}
+
+// CHECK-DAG: void @_ZW3FOOW3BAZ3BarPS_W3BAR1APN3BobS1_1BE(
+void Bar (A *, Bob::B*) {
+}

clang/test/CodeGenCXX/cxx20-module-tmpl-1.cppm

+// RUN: %clang_cc1 -std=c++20 %s -triple %itanium_abi_triple -emit-llvm -o - | FileCheck %s
+
+export module FOO;
+
+class One;
+class Two;
+
+export template<typename T> struct TPL
+{
+void M (T *);
+template<typename U> void N (T *, U*);
+};
+
+template<typename T>
+void TPL<T>::M (T *) {}
+
+template<typename T> template<typename U> void TPL<T>::N (T *, U*) {}
+
+// CHECK-DAG: void @_ZNW3FOO3TPLIS_3OneE1MEPS1_(
+template void TPL<One>::M (One *);
+// CHECK-DAG: void @_ZNW3FOO3TPLIS_3OneE1NIS_3TwoEEvPS1_PT_(
+template void TPL<One>::N<Two> (One *, Two *);
+
+namespace NMS {
+class One;
+class Two;
+
+export template<typename T> struct TPL
+{
+void M (T *);
+template<typename U> void N (T *, U*);
+};
+
+template<typename T>
+void TPL<T>::M (T *) {}
+
+template<typename T> template<typename U> void TPL<T>::N (T *, U*) {}
+
+// CHECK-DAG: void @_ZN3NMSW3FOO3TPLINS_S0_3OneEE1MEPS2_(
+template void TPL<One>::M (One *);
+// CHECK-DAG: void @_ZN3NMSW3FOO3TPLINS_S0_3OneEE1NINS_S0_3TwoEEEvPS2_PT_
+template void TPL<One>::N<Two> (One *, Two *);
+}