[clang] Module global init mangling

[urnathan]

Summary

C++20 modules require emission of an initializer function, which is called by importers of the module. This implements the mangling for that function. It is the one place the ABI exposes partition names in symbols -- but fortunately only needed by other TUs of that same module.

[bruno]

clang/lib/AST/ItaniumMangle.cpp

6545

Can you add a brief comment on what _ZGI means? LGTM with that change.

[bruno]

Forgot to ask, is there anything preventing a testcase to be added here?

[urnathan]

In D122741#3417053, @bruno wrote:

Forgot to ask, is there anything preventing a testcase to be added here?

nothing is there to ask for the name (yet), @iains has it in his queue

[iains]

(in initial testing) it seems that in the places we need to make the global initialisers, the mangling context is not Itanium-specific (although, presumably I could make the module initialiser conditional on that).

Do we know if there's a plan to implement the MS-specific mangling? (for now, I've hacked around this with a nonsensical implementation for MS in order to make progress on testing the initialiser code).

[urnathan]

In D122741#3422696, @iains wrote:

Do we know if there's a plan to implement the MS-specific mangling? (for now, I've hacked around this with a nonsensical implementation for MS in order to make progress on testing the initialiser code).

I'll ask Microsoft what that mangling is.

[urnathan]

In D122741#3425899, @urnathan wrote:

In D122741#3422696, @iains wrote:

Do we know if there's a plan to implement the MS-specific mangling? (for now, I've hacked around this with a nonsensical implementation for MS in order to make progress on testing the initialiser code).

I'll ask Microsoft what that mangling is.

I have received no response

[iains]

In D122741#3471660, @urnathan wrote:

In D122741#3425899, @urnathan wrote:

In D122741#3422696, @iains wrote:

Do we know if there's a plan to implement the MS-specific mangling? (for now, I've hacked around this with a nonsensical implementation for MS in order to make progress on testing the initialiser code).

I'll ask Microsoft what that mangling is.

I have received no response

I have revised my code (which I suspect will be the first user of this) to use the patch here as-is, so this LGTM (and we can add mangling for Microsoft at a later time).

clang/include/clang/AST/Mangle.h

virtual void mangleCXXCtorComdat(const CXXConstructorDecl *D,
                                    raw_ostream &) = 0;
   virtual void mangleCXXDtorComdat(const CXXDestructorDecl *D,
                                    raw_ostream &) = 0;
 
   virtual void mangleLambdaSig(const CXXRecordDecl *Lambda, raw_ostream &) = 0;
 
   virtual void mangleDynamicStermFinalizer(const VarDecl *D, raw_ostream &) = 0;
 
+  virtual void mangleModuleInitializer(const Module *Module, raw_ostream &) = 0;
+
   // This has to live here, otherwise the CXXNameMangler won't have access to
   // it.
   virtual DiscriminatorOverrideTy getDiscriminatorOverride() const = 0;
   static bool classof(const MangleContext *C) {
     return C->getKind() == MK_Itanium;
   }
 
   static ItaniumMangleContext *

clang/lib/AST/ItaniumMangle.cpp

public:
   void mangleItaniumThreadLocalInit(const VarDecl *D, raw_ostream &) override;
   void mangleItaniumThreadLocalWrapper(const VarDecl *D,
                                        raw_ostream &) override;
 
   void mangleStringLiteral(const StringLiteral *, raw_ostream &) override;
 
   void mangleLambdaSig(const CXXRecordDecl *Lambda, raw_ostream &) override;
 
+  void mangleModuleInitializer(const Module *Module, raw_ostream &) override;
+
   bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) {
     // Lambda closure types are already numbered.
     if (isLambda(ND))
       return false;
 
     // Anonymous tags are already numbered.
     if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
       if (Tag->getName().empty() && !Tag->getTypedefNameForAnonDecl())
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);
+  void mangleModuleNamePrefix(StringRef Name, bool IsPartition = false);
 
 private:
 
   bool mangleSubstitution(const NamedDecl *ND);
   bool mangleSubstitution(NestedNameSpecifier *NNS);
   bool mangleSubstitution(QualType T);
   bool mangleSubstitution(TemplateName Template);
   bool mangleSubstitution(uintptr_t Ptr);
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) {
+//        ::= W P <source-name>
+void CXXNameMangler::mangleModuleNamePrefix(StringRef Name, bool IsPartition) {
   //  <substitution> ::= S <seq-id> _
   auto It = ModuleSubstitutions.find(Name);
   if (It != ModuleSubstitutions.end()) {
     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);
+  else {
+    mangleModuleNamePrefix(Parts.first, IsPartition);
+    IsPartition = false;
+  }
 
   Out << 'W';
+  if (IsPartition)
+    Out << 'P';
   Out << Parts.second.size() << Parts.second;
   ModuleSubstitutions.insert({Name, SeqID++});
 }
 
 void CXXNameMangler::mangleTemplateName(const TemplateDecl *TD,
                                         const TemplateArgument *TemplateArgs,
                                         unsigned NumTemplateArgs) {
   const DeclContext *DC = Context.getEffectiveDeclContext(TD);

 }
 
 void ItaniumMangleContextImpl::mangleLambdaSig(const CXXRecordDecl *Lambda,
                                                raw_ostream &Out) {
   CXXNameMangler Mangler(*this, Out);
   Mangler.mangleLambdaSig(Lambda);
 }
 
+void ItaniumMangleContextImpl::mangleModuleInitializer(const Module *M,
+                                                       raw_ostream &Out) {
+  // <special-name> ::= GI <module-name>  # module initializer function
+  CXXNameMangler Mangler(*this, Out);
+  Mangler.getStream() << "_ZGI";
+  Mangler.mangleModuleNamePrefix(M->getPrimaryModuleInterfaceName());
+  if (M->isModulePartition()) {
+    // The partition needs including, as partitions can have them too.
+    auto Partition = M->Name.find(':');
+    Mangler.mangleModuleNamePrefix(
+        StringRef(&M->Name[Partition + 1], M->Name.size() - Partition - 1),
+        /*IsPartition*/ true);
+  }
+}
+
 ItaniumMangleContext *ItaniumMangleContext::create(ASTContext &Context,
                                                    DiagnosticsEngine &Diags,
                                                    bool IsAux) {
   return new ItaniumMangleContextImpl(
       Context, Diags,
       [](ASTContext &, const NamedDecl *) -> llvm::Optional<unsigned> {
         return llvm::None;
       },