[C++20] [Modules] Support to export declarations in the language linkage

[ChuanqiXu]

Summary

Close https://github.com/llvm/llvm-project/issues/60405

See the discussion in the above link for the background.

What the patch does:

• Rename Module::ModuleKind::GlobalModuleFragment to Module::ModuleKind::ExplicitGlobalModuleFragment.
• Add another module kind ImplicitGlobalModuleFragment to ModuleKind.
• Create an implicit global module fragment for the language linkage declarations inside a module purview.
  • If the language linkage lives inside the scope of an export decl, the created modules is marked as exported to outer modules.
• In fact, Sema will only create at most 2 implicit global module fragments to avoid creating a lot of unnecessary modules in the edging case.

[ChuanqiXu]

clang/include/clang/Sema/Sema.h

2284–2291

This is important otherwise it will be bad if the users write many:

export extern "C++" void f1();
export extern "C++" void f2();
export extern "C++" void f3();
// ...

clang/test/Modules/export-language-linkage.cppm

42–48

We can classify each language linkage into exported/unexported since export is not allowed in unnamed modules.

[iains]

I am wondering why we need to add another sub-module.

We can identify that the current decl is a language linkage one (and make sure that it is not marked as eligible for elision when that is implemented) - so that we can be sure it is not subject to the elision rules.

If there is already an existing GMF, is it not possible to switch to that when handling the language linkage case? (to avoid creating a second GMF).

(I can understand if "no" is the answer - but just checking).

.. otherwise, mostly nits on comments etc.

clang/include/clang/Basic/Module.h

123–126

This is well-specified, I think we can just refer to that.

130–131

this one is the new thing.

clang/include/clang/Sema/Sema.h

2280–2281

let's just refer to the spec.

2285–2286

why do we need even two?

2288–2289

for there to be content, it must be exported, right? (the implicit case is only used for language linkage AFAIU).

2291

typo?

[ChuanqiXu]

In D144367#4140076, @iains wrote:

I am wondering why we need to add another sub-module.

From my minds, because it looks like not a burden to me to add other sub-modules? For example, both the existing GMF and the PMF are the sub-modules. So I feel it looks more straightforward to implement it in this way.

We can identify that the current decl is a language linkage one (and make sure that it is not marked as eligible for elision when that is implemented) - so that we can be sure it is not subject to the elision rules.

If there is already an existing GMF, is it not possible to switch to that when handling the language linkage case? (to avoid creating a second GMF).

(I can understand if "no" is the answer - but just checking).

I don't say "it is impossible". But I want to say it looks odd and ad-hoc. The intention of the patch is to allow us to export the contents in language linkage. But the contents of language linkage belongs to GMF. In the current implementation, all the contents in GMF is not visible to outside. Is it possible for us to insert such codes in the isVisible path?

if ((D belongs to GMF) and (D belongs to language linkage) and (D belongs to export decl))
     return true;

This should be able to work with the 2 issues:

1. It smells not good to lookup export decl. On the one hand, it seems like we need a lot iterations to look for the parent decl context for D again and again until we meet export decl or the file context. On the other hand, this is not consistency with our current method to handle visibility lookup. We can image that we can refactor all of the current visibility lookup into the style. (Lookup if this declaration lives in an export decl). But it looks inconsistent and not good to me.
2. In the edge case that the module of D get loaded but not imported, the above code can't work. This is possible if we load a module by -fmodule-file=module but don't import the corresponding module. To handle the case, we need to rewrite the above code into:

if ((D belongs to GMF) and (D belongs to language linkage) and (D belongs to export decl) and (The top level module of D is imported))
     return true;

which looks odder, doesn't it?

So my idea will be:
(1) On the language side, we can have multiple GMFs in a single module unit.
(2) On the implementation side, currently some modules are divided into visible modules while other modules are classified into invisible modules (like current GMF).
(3) So it makes sense to me to create a new GMF kind which is visible modules.

clang/include/clang/Sema/Sema.h

2285–2286

Currently, it is fine to introduce TheExportedImplicitGlobalModuleFragment only since all the declarations in GMF wouldn't get discarded. But it is helpful when we want to discard declarations in the GMF. I add the 2 modules now since I feel it doesn't add the overhead and the current style is consistent the mental model.

2288–2289

The language linkage can be able to be not exported.

2291

Yes, I will fix it later.

[iains]

OK - the visibility path is already complex, we do not need to make it more so.
I guess you are intending to rebase/update this?

clang/include/clang/Sema/Sema.h

2285–2286

ah, OK, then it is my misreading of the comment (it seemed to be saying that there could be two implicit global module fragments) - but you mean 1 explicit + 1 implicit, correct?

[ChuanqiXu]

Address comments.

[ChuanqiXu]

Oh, I forgot to commit the comment.

clang/include/clang/Sema/Sema.h

2285–2286

No, I mean 2 implicit GMFs. One for exported and one for unexported. Although it will work fine from the perspective of functionality if we merge the unexported implicit GMFs into the explicit GMF, the semantics is not consistency. For example:

export module a;
extern "C++" void foo() {}
export extern "C++" void bar() {}

It will be a little bit odd to me if foo belongs to the explicit global module fragment in the compiler since it is not true in the language side. And from the perspective of implementation side, foo() and bar() can't be in the same (sub) module. So we create 2 modules here. One for exported and one for unexported. This may be a little bit overhead but I think it doesn't matter.

[ChuanqiXu]

@iains ping~ I want to land this one in the next week if no comments come in.

[iains]

In D144367#4154225, @ChuanqiXu wrote:

@iains ping~ I want to land this one in the next week if no comments come in.

I will try to review during this week.

One quick question : does the revised module layout work OK with "-module-file-info" which should print the summary of the C++20 content in the first few lines.

[ChuanqiXu]

Add test for '-module-file-info'

[ChuanqiXu]

In D144367#4155267, @iains wrote:

In D144367#4154225, @ChuanqiXu wrote:

@iains ping~ I want to land this one in the next week if no comments come in.

I will try to review during this week.

One quick question : does the revised module layout work OK with "-module-file-info" which should print the summary of the C++20 content in the first few lines.

Yeah, I've added the test for it.

[iains]

In D144367#4157589, @ChuanqiXu wrote:

In D144367#4155267, @iains wrote:

In D144367#4154225, @ChuanqiXu wrote:

@iains ping~ I want to land this one in the next week if no comments come in.

I will try to review during this week.

One quick question : does the revised module layout work OK with "-module-file-info" which should print the summary of the C++20 content in the first few lines.

Yeah, I've added the test for it.

Something seems strange, I cannot see that new test in the web page content?

[ChuanqiXu]

In D144367#4157732, @iains wrote:

In D144367#4157589, @ChuanqiXu wrote:

In D144367#4155267, @iains wrote:

In D144367#4154225, @ChuanqiXu wrote:

@iains ping~ I want to land this one in the next week if no comments come in.

I will try to review during this week.

One quick question : does the revised module layout work OK with "-module-file-info" which should print the summary of the C++20 content in the first few lines.

Yeah, I've added the test for it.

Something seems strange, I cannot see that new test in the web page content?

See the inline comments.

clang/test/Modules/export-language-linkage.cppm

28–30

I add the test here.

[iains]

OK, I guess one extra sub-module is not too bad.
LGTM.

clang/docs/ReleaseNotes.rst

- Fix confusing warning message when ``/clang:-x`` is passed in ``clang-cl``
   ``clang-cl`` options instead.
   (`#59307 <https://github.com/llvm/llvm-project/issues/59307>`_)
 - Fix assert that fails when the expression causing the this pointer to be
   captured by a block is part of a constexpr if statement's branch and
   instantiation of the enclosing method causes the branch to be discarded.
 - Fix __VA_OPT__ implementation so that it treats the concatenation of a
   non-placemaker token and placemaker token as a non-placemaker token.
   (`#60268 <https://github.com/llvm/llvm-project/issues/60268>`_)
+- Clang now support export declarations in the language linkage.
+  (`#60405 <https://github.com/llvm/llvm-project/issues/60405>`_)
 
 Bug Fixes to Compiler Builtins
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to Attribute Support
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Bug Fixes to C++ Support

clang/include/clang/Basic/Module.h

enum ModuleKind {
     ModuleHeaderUnit,
 
     /// This is a C++ 20 module partition interface.
     ModulePartitionInterface,
 
     /// This is a C++ 20 module partition implementation.
     ModulePartitionImplementation,
 
-    /// This is a fragment of the global module within some C++ module.
-    GlobalModuleFragment,
+    /// This is the explicit Global Module Fragment of a modular TU.
+    /// As per C++ [module.global.frag].
+    ExplicitGlobalModuleFragment,
 
     /// This is the private module fragment within some C++ module.
     PrivateModuleFragment,
+
+    /// This is an implicit fragment of the global module which contains
+    /// only language linkage declarations (made in the purview of the
+    /// named module).
+    ImplicitGlobalModuleFragment,
   };
 
   /// The kind of this module.
   ModuleKind Kind = ModuleMapModule;
 
   /// The parent of this module. This will be NULL for the top-level
   /// module.
   Module *Parent;
public:
   bool isModulePurview() const {
     return Kind == ModuleInterfaceUnit || Kind == ModulePartitionInterface ||
            Kind == ModulePartitionImplementation ||
            Kind == PrivateModuleFragment;
   }
 
   /// Does this Module scope describe a fragment of the global module within
   /// some C++ module.
-  bool isGlobalModule() const { return Kind == GlobalModuleFragment; }
+  bool isGlobalModule() const {
+    return isExplicitGlobalModule() || isImplicitGlobalModule();
+  }
+  bool isExplicitGlobalModule() const {
+    return Kind == ExplicitGlobalModuleFragment;
+  }
+  bool isImplicitGlobalModule() const {
+    return Kind == ImplicitGlobalModuleFragment;
+  }
 
   bool isPrivateModule() const { return Kind == PrivateModuleFragment; }
 
   bool isModuleMapModule() const { return Kind == ModuleMapModule; }
 
 private:
   /// The submodules of this module, indexed by name.
   std::vector<Module *> SubModules;

clang/include/clang/Lex/ModuleMap.h

public:
   ///
   /// We model the global module fragment as a submodule of the module
   /// interface unit. Unfortunately, we can't create the module interface
   /// unit's Module until later, because we don't know what it will be called
   /// usually. See C++20 [module.unit]/7.2 for the case we could know its
   /// parent.
   Module *createGlobalModuleFragmentForModuleUnit(SourceLocation Loc,
                                                   Module *Parent = nullptr);
+  Module *createImplicitGlobalModuleFragmentForModuleUnit(
+      SourceLocation Loc, bool IsExported, Module *Parent = nullptr);
 
   /// Create a global module fragment for a C++ module interface unit.
   Module *createPrivateModuleFragmentForInterfaceUnit(Module *Parent,
                                                       SourceLocation Loc);
 
   /// Create a new module for a C++ module interface unit.
   /// The module must not already exist, and will be configured for the current
   /// compilation.

clang/include/clang/Sema/Sema.h

private:
   struct ModuleScope {
     SourceLocation BeginLoc;
     clang::Module *Module = nullptr;
     bool ModuleInterface = false;
     VisibleModuleSet OuterVisibleModules;
   };
   /// The modules we're currently parsing.
   llvm::SmallVector<ModuleScope, 16> ModuleScopes;
-  /// The global module fragment of the current translation unit.
-  clang::Module *GlobalModuleFragment = nullptr;
+  /// The explicit global module fragment of the current translation unit.
+  /// The explicit Global Module Fragment, as specified in C++
+  /// [module.global.frag].
+  clang::Module *TheGlobalModuleFragment = nullptr;
+
+  /// The implicit global module fragments of the current translation unit.
+  /// We would only create at most two implicit global module fragments to
+  /// avoid performance penalties when there are many language linkage
+  /// exports.
+  ///
+  /// The contents in the implicit global module fragment can't be discarded
+  /// no matter if it is exported or not.
+  clang::Module *TheImplicitGlobalModuleFragment = nullptr;
+  clang::Module *TheExportedImplicitGlobalModuleFragment = nullptr;
 
   /// Namespace definitions that we will export when they finish.
   llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces;
 
   /// In a C++ standard module, inline declarations require a definition to be
   /// present at the end of a definition domain.  This set holds the decls to
   /// be checked at the end of the TU.
   llvm::SmallPtrSet<const FunctionDecl *, 8> PendingInlineFuncDecls;
 
   /// Helper function to judge if we are in module purview.
   /// Return false if we are not in a module.
   bool isCurrentModulePurview() const {
     return getCurrentModule() ? getCurrentModule()->isModulePurview() : false;
   }
 
-  /// Enter the scope of the global module.
+  /// Enter the scope of the explicit global module fragment.
   Module *PushGlobalModuleFragment(SourceLocation BeginLoc);
-  /// Leave the scope of the global module.
+  /// Leave the scope of the explicit global module fragment.
   void PopGlobalModuleFragment();
 
+  /// Enter the scope of an implicit global module fragment.
+  Module *PushImplicitGlobalModuleFragment(SourceLocation BeginLoc,
+                                           bool IsExported);
+  /// Leave the scope of an implicit global module fragment.
+  void PopImplicitGlobalModuleFragment();
+
   VisibleModuleSet VisibleModules;
 
   /// Cache for module units which is usable for current module.
   llvm::DenseSet<const Module *> UsableModuleUnitsCache;
 
   bool isUsableModule(const Module *M);
 
   bool isAcceptableSlow(const NamedDecl *D, AcceptableKind Kind);

clang/lib/AST/Decl.cpp

case Module::ModuleMapModule:
     return nullptr;
 
   case Module::ModuleInterfaceUnit:
   case Module::ModulePartitionInterface:
   case Module::ModulePartitionImplementation:
     return M;
 
   case Module::ModuleHeaderUnit:
-  case Module::GlobalModuleFragment: {
+  case Module::ExplicitGlobalModuleFragment:
+  case Module::ImplicitGlobalModuleFragment: {
     // External linkage declarations in the global module have no owning module
     // for linkage purposes. But internal linkage declarations in the global
     // module fragment of a particular module are owned by that module for
     // linkage purposes.
     // FIXME: p1815 removes the need for this distinction -- there are no
     // internal linkage declarations that need to be referred to from outside
     // this TU.
     if (IgnoreLinkage)

clang/lib/Frontend/FrontendActions.cpp

static StringRef ModuleKindName(Module::ModuleKind MK) {
   case Module::ModuleInterfaceUnit:
     return "Interface Unit";
   case Module::ModulePartitionInterface:
     return "Partition Interface";
   case Module::ModulePartitionImplementation:
     return "Partition Implementation";
   case Module::ModuleHeaderUnit:
     return "Header Unit";
-  case Module::GlobalModuleFragment:
+  case Module::ExplicitGlobalModuleFragment:
     return "Global Module Fragment";
+  case Module::ImplicitGlobalModuleFragment:
+    return "Implicit Module Fragment";
   case Module::PrivateModuleFragment:
     return "Private Module Fragment";
   }
   llvm_unreachable("unknown module kind!");
 }
 
 void DumpModuleInfoAction::ExecuteAction() {
   assert(isCurrentFileAST() && "dumping non-AST?");

clang/lib/Lex/ModuleMap.cpp

std::pair<Module *, bool> ModuleMap::findOrCreateModule(StringRef Name,
   }
   return std::make_pair(Result, true);
 }
 
 Module *ModuleMap::createGlobalModuleFragmentForModuleUnit(SourceLocation Loc,
                                                            Module *Parent) {
   auto *Result = new Module("<global>", Loc, Parent, /*IsFramework*/ false,
                             /*IsExplicit*/ true, NumCreatedModules++);
-  Result->Kind = Module::GlobalModuleFragment;
+  Result->Kind = Module::ExplicitGlobalModuleFragment;
   // If the created module isn't owned by a parent, send it to PendingSubmodules
   // to wait for its parent.
   if (!Result->Parent)
     PendingSubmodules.emplace_back(Result);
   return Result;
 }
 
+Module *ModuleMap::createImplicitGlobalModuleFragmentForModuleUnit(
+    SourceLocation Loc, bool IsExported, Module *Parent) {
+  assert(Parent && "We should only create an implicit global module fragment "
+                   "in a module purview");
+  // Note: Here the `IsExplicit` parameter refers to the semantics in clang
+  // modules. All the non-explicit submodules in clang modules will be exported
+  // too. Here we simplify the implementation by using the concept.
+  auto *Result = new Module(IsExported ? "<exported implicit global>"
+                                       : "<implicit global>",
+                            Loc, Parent, /*IsFramework*/ false,
+                            /*IsExplicit*/ !IsExported, NumCreatedModules++);
+  Result->Kind = Module::ImplicitGlobalModuleFragment;
+  return Result;
+}
+
 Module *
 ModuleMap::createPrivateModuleFragmentForInterfaceUnit(Module *Parent,
                                                        SourceLocation Loc) {
   auto *Result =
       new Module("<private>", Loc, Parent, /*IsFramework*/ false,
                  /*IsExplicit*/ true, NumCreatedModules++);
   Result->Kind = Module::PrivateModuleFragment;
   return Result;

clang/lib/Sema/Sema.cpp

void Sema::ActOnEndOfTranslationUnit() {
   if (!Diags.hasErrorOccurred()) {
     if (ExternalSource)
       ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
     checkUndefinedButUsed(*this);
   }
 
   // A global-module-fragment is only permitted within a module unit.
   bool DiagnosedMissingModuleDeclaration = false;
-  if (!ModuleScopes.empty() &&
-      ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment) {
+  if (!ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
+                                   Module::ExplicitGlobalModuleFragment) {
     Diag(ModuleScopes.back().BeginLoc,
          diag::err_module_declaration_missing_after_global_module_introducer);
     DiagnosedMissingModuleDeclaration = true;
   }
 
   if (TUKind == TU_Module) {
     // If we are building a module interface unit, we need to have seen the
     // module declaration by now.

clang/lib/Sema/SemaDeclCXX.cpp

   ///   - ...
   ///   - ...
   ///   - appears within a linkage-specification,
   ///   it is attached to the global module.
   ///
   /// If the declaration is already in global module fragment, we don't
   /// need to attach it again.
   if (getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
-    Module *GlobalModule =
-        PushGlobalModuleFragment(ExternLoc);
-    /// According to [module.reach]p3.2,
-    /// The declaration in global module fragment is reachable if it is not
-    /// discarded. And the discarded declaration should be deleted. So it
-    /// doesn't matter mark the declaration in global module fragment as
-    /// reachable here.
-    D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ReachableWhenImported);
+    Module *GlobalModule = PushImplicitGlobalModuleFragment(
+        ExternLoc, /*IsExported=*/D->isInExportDeclContext());
     D->setLocalOwningModule(GlobalModule);
   }
 
   CurContext->addDecl(D);
   PushDeclContext(S, D);
   return D;
 }
 

     LSDecl->setRBraceLoc(RBraceLoc);
   }
 
   // If the current module doesn't has Parent, it implies that the
   // LinkageSpec isn't in the module created by itself. So we don't
   // need to pop it.
   if (getLangOpts().CPlusPlusModules && getCurrentModule() &&
       getCurrentModule()->isGlobalModule() && getCurrentModule()->Parent)
-    PopGlobalModuleFragment();
+    PopImplicitGlobalModuleFragment();
 
   PopDeclContext();
   return LinkageSpec;
 }
 
 Decl *Sema::ActOnEmptyDeclaration(Scope *S,
                                   const ParsedAttributesView &AttrList,
                                   SourceLocation SemiLoc) {

clang/lib/Sema/SemaExprCXX.cpp

StdBadAlloc = CXXRecordDecl::Create(Context, TTK_Class,
                                         getOrCreateStdNamespace(),
                                         SourceLocation(), SourceLocation(),
                                       &PP.getIdentifierTable().get("bad_alloc"),
                                         nullptr);
     getStdBadAlloc()->setImplicit(true);
 
     // The implicitly declared "std::bad_alloc" should live in global module
     // fragment.
-    if (GlobalModuleFragment) {
+    if (TheGlobalModuleFragment) {
       getStdBadAlloc()->setModuleOwnershipKind(
           Decl::ModuleOwnershipKind::ReachableWhenImported);
-      getStdBadAlloc()->setLocalOwningModule(GlobalModuleFragment);
+      getStdBadAlloc()->setLocalOwningModule(TheGlobalModuleFragment);
     }
   }
   if (!StdAlignValT && getLangOpts().AlignedAllocation) {
     // The "std::align_val_t" enum class has not yet been declared, so build it
     // implicitly.
     auto *AlignValT = EnumDecl::Create(
         Context, getOrCreateStdNamespace(), SourceLocation(), SourceLocation(),
         &PP.getIdentifierTable().get("align_val_t"), nullptr, true, true, true);
 
     // The implicitly declared "std::align_val_t" should live in global module
     // fragment.
-    if (GlobalModuleFragment) {
+    if (TheGlobalModuleFragment) {
       AlignValT->setModuleOwnershipKind(
           Decl::ModuleOwnershipKind::ReachableWhenImported);
-      AlignValT->setLocalOwningModule(GlobalModuleFragment);
+      AlignValT->setLocalOwningModule(TheGlobalModuleFragment);
     }
 
     AlignValT->setIntegerType(Context.getSizeType());
     AlignValT->setPromotionType(Context.getSizeType());
     AlignValT->setImplicit(true);
 
     StdAlignValT = AlignValT;
   }
auto CreateAllocationFunctionDecl = [&](Attr *ExtraAttr) {
     //   and deallocation functions. Some global allocation and deallocation
     //   functions are replaceable ([new.delete]); these are attached to the
     //   global module ([module.unit]).
     //
     // In the language wording, these functions are attched to the global
     // module all the time. But in the implementation, the global module
     // is only meaningful when we're in a module unit. So here we attach
     // these allocation functions to global module conditionally.
-    if (GlobalModuleFragment) {
+    if (TheGlobalModuleFragment) {
       Alloc->setModuleOwnershipKind(
           Decl::ModuleOwnershipKind::ReachableWhenImported);
-      Alloc->setLocalOwningModule(GlobalModuleFragment);
+      Alloc->setLocalOwningModule(TheGlobalModuleFragment);
     }
 
     Alloc->addAttr(VisibilityAttr::CreateImplicit(
         Context, LangOpts.GlobalAllocationFunctionVisibilityHidden
                      ? VisibilityAttr::Hidden
                      : VisibilityAttr::Default));
 
     llvm::SmallVector<ParmVarDecl *, 3> ParamDecls;

clang/lib/Sema/SemaLookup.cpp

bool Sema::isUsableModule(const Module *M) {
   if (UsableModuleUnitsCache.count(M))
     return true;
 
   // If M is the global module fragment of the current translation unit. So it
   // should be usable.
   // [module.global.frag]p1:
   //   The global module fragment can be used to provide declarations that are
   //   attached to the global module and usable within the module unit.
-  if (M == GlobalModuleFragment ||
+  if (M == TheGlobalModuleFragment ||
       // If M is the module we're parsing, it should be usable. This covers the
       // private module fragment. The private module fragment is usable only if
       // it is within the current module unit. And it must be the current
       // parsing module unit if it is within the current module unit according
       // to the grammar of the private module fragment. NOTE: This is covered by
       // the following condition. The intention of the check is to avoid string
       // comparison as much as possible.
       M == getCurrentModule() ||

clang/lib/Sema/SemaModule.cpp

Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
   if (isCurrentModulePurview()) {
     Diag(ModuleLoc, diag::err_module_redeclaration);
     Diag(VisibleModules.getImportLoc(ModuleScopes.back().Module),
          diag::note_prev_module_declaration);
     return nullptr;
   }
 
   assert((!getLangOpts().CPlusPlusModules ||
-          SeenGMF == (bool)this->GlobalModuleFragment) &&
+          SeenGMF == (bool)this->TheGlobalModuleFragment) &&
          "mismatched global module state");
 
   // In C++20, the module-declaration must be the first declaration if there
   // is no global module fragment.
   if (getLangOpts().CPlusPlusModules && !IsFirstDecl && !SeenGMF) {
     Diag(ModuleLoc, diag::err_module_decl_not_at_start);
     SourceLocation BeginLoc =
         ModuleScopes.empty()
Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
   case ModuleDeclKind::PartitionImplementation:
     // Create an interface, but note that it is an implementation
     // unit.
     Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName);
     Mod->Kind = Module::ModulePartitionImplementation;
     break;
   }
 
-  if (!this->GlobalModuleFragment) {
+  if (!this->TheGlobalModuleFragment) {
     ModuleScopes.push_back({});
     if (getLangOpts().ModulesLocalVisibility)
       ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
   } else {
     // We're done with the global module fragment now.
     ActOnEndOfTranslationUnitFragment(TUFragmentKind::Global);
   }
 

 }
 
 Sema::DeclGroupPtrTy
 Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
                                      SourceLocation PrivateLoc) {
   // C++20 [basic.link]/2:
   //   A private-module-fragment shall appear only in a primary module
   //   interface unit.
-  switch (ModuleScopes.empty() ? Module::GlobalModuleFragment
+  switch (ModuleScopes.empty() ? Module::ExplicitGlobalModuleFragment
                                : ModuleScopes.back().Module->Kind) {
   case Module::ModuleMapModule:
-  case Module::GlobalModuleFragment:
+  case Module::ExplicitGlobalModuleFragment:
+  case Module::ImplicitGlobalModuleFragment:
   case Module::ModulePartitionImplementation:
   case Module::ModulePartitionInterface:
   case Module::ModuleHeaderUnit:
     Diag(PrivateLoc, diag::err_private_module_fragment_not_module);
     return nullptr;
 
   case Module::PrivateModuleFragment:
     Diag(PrivateLoc, diag::err_private_module_fragment_redefined);
Decl *Sema::ActOnFinishExportDecl(Scope *S, Decl *D, SourceLocation RBraceLoc) {
   }
 
   return D;
 }
 
 Module *Sema::PushGlobalModuleFragment(SourceLocation BeginLoc) {
   // We shouldn't create new global module fragment if there is already
   // one.
-  if (!GlobalModuleFragment) {
+  if (!TheGlobalModuleFragment) {
     ModuleMap &Map = PP.getHeaderSearchInfo().getModuleMap();
-    GlobalModuleFragment = Map.createGlobalModuleFragmentForModuleUnit(
+    TheGlobalModuleFragment = Map.createGlobalModuleFragmentForModuleUnit(
         BeginLoc, getCurrentModule());
   }
 
-  assert(GlobalModuleFragment && "module creation should not fail");
+  assert(TheGlobalModuleFragment && "module creation should not fail");
 
   // Enter the scope of the global module.
-  ModuleScopes.push_back({BeginLoc, GlobalModuleFragment,
+  ModuleScopes.push_back({BeginLoc, TheGlobalModuleFragment,
                           /*ModuleInterface=*/false,
                           /*OuterVisibleModules=*/{}});
-  VisibleModules.setVisible(GlobalModuleFragment, BeginLoc);
+  VisibleModules.setVisible(TheGlobalModuleFragment, BeginLoc);
 
-  return GlobalModuleFragment;
+  return TheGlobalModuleFragment;
 }
 
 void Sema::PopGlobalModuleFragment() {
-  assert(!ModuleScopes.empty() && getCurrentModule()->isGlobalModule() &&
+  assert(!ModuleScopes.empty() &&
+         getCurrentModule()->isExplicitGlobalModule() &&
+         "left the wrong module scope, which is not global module fragment");
+  ModuleScopes.pop_back();
+}
+
+Module *Sema::PushImplicitGlobalModuleFragment(SourceLocation BeginLoc,
+                                               bool IsExported) {
+  Module **M = IsExported ? &TheExportedImplicitGlobalModuleFragment
+                          : &TheImplicitGlobalModuleFragment;
+  if (!*M) {
+    ModuleMap &Map = PP.getHeaderSearchInfo().getModuleMap();
+    *M = Map.createImplicitGlobalModuleFragmentForModuleUnit(
+        BeginLoc, IsExported, getCurrentModule());
+  }
+  assert(*M && "module creation should not fail");
+
+  // Enter the scope of the global module.
+  ModuleScopes.push_back({BeginLoc, *M,
+                          /*ModuleInterface=*/false,
+                          /*OuterVisibleModules=*/{}});
+  VisibleModules.setVisible(*M, BeginLoc);
+  return *M;
+}
+
+void Sema::PopImplicitGlobalModuleFragment() {
+  assert(!ModuleScopes.empty() &&
+         getCurrentModule()->isImplicitGlobalModule() &&
          "left the wrong module scope, which is not global module fragment");
   ModuleScopes.pop_back();
 }
 
 bool Sema::isModuleUnitOfCurrentTU(const Module *M) const {
   assert(M);
 
   Module *CurrentModuleUnit = getCurrentModule();
 
   // If we are not in a module currently, M must not be the module unit of
   // current TU.
   if (!CurrentModuleUnit)
     return false;
 
   return M->isSubModuleOf(CurrentModuleUnit->getTopLevelModule());
 }

clang/test/Modules/export-language-linkage.cppm

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: cd %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/a.cppm -emit-module-interface -o %t/a.pcm
+// RUN: %clang_cc1 -std=c++20 %t/b.cpp -fmodule-file=a=%t/a.pcm -fsyntax-only -verify
+// RUN: %clang_cc1 -std=c++20 %t/c.cppm -fsyntax-only -verify
+
+//--- a.cppm
+export module a;
+export extern "C++" int foo() { return 43; }
+export extern "C++" {
+    int a();
+    int b();
+    int c();
+}
+
+export {
+    extern "C++" void f1();
+    extern "C++" void f2();
+    extern "C++" void f3();
+}
+
+extern "C++" void unexported();
+
+//--- b.cpp
+import a;
+int use() {
+    a();
+    b();
+    c();
+    f1();
+    f2();
+    f3();
+    unexported(); // expected-error {{missing '#include'; 'unexported' must be declared before it is used}}
+                   // [e-mail]:15 {{declaration here is not visible}}
+    return foo();
+}
+
+//--- c.cppm
+export module c;
+extern "C++" {
+    // We can't use `export` in an unnamed module.
+    export int f(); // expected-error {{export declaration can only be used within a module purview}}
+}
+
+extern "C++" export int g(); // expected-error {{export declaration can only be used within a module purview}}