[C++20] [Modules] Don't generate strong function of a partition in importing modules

[ChuanqiXu]

Summary

This solves the multiple defintiion issue https://github.com/llvm/llvm-project/issues/54269.

I think the cause of the bug might be an oversight. We just forget to edit this when implementing partitions. And it should be a good fix.

[iains]

I think you need to extend the test case (and possibly the code) to handle an implementation partition as well, where the module is both interface and implementation.

[ChuanqiXu]

Address comments

[ChuanqiXu]

In D121271#3369276, @iains wrote:

I think you need to extend the test case (and possibly the code) to handle an implementation partition as well, where the module is both interface and implementation.

Yeah, this is the intention of partb (maybe I took a typo).

---

Also, I found all the CodeGen tests patch would better to depend D118352 otherwise @urnathan might need to rebase again or we need to unnecessary rebase.

[iains]

thanks, this looks OK to me, but I would leave some time for other comments.

[ChuanqiXu]

@iains ping

[iains]

it looks like the test case is failing everywhere - perhaps as a result of changes in the mangling scheme?

[ChuanqiXu]

In D121271#3394108, @iains wrote:

it looks like the test case is failing everywhere - perhaps as a result of changes in the mangling scheme?

Oh, yeah... let me try to continue the work in mangling scheme. I feel it is important otherwise it is not so good to demangle.

[iains]

it looks like the first part of the C++20 mangling was just landed, so perhaps you can revisit this?

[ChuanqiXu]

Rebase

[ChuanqiXu]

Specify itanium_abi_triple to make CI on windows passes.

[ChuanqiXu]

@iains now it passes the CI!

[iains]

LGTM, thanks.

clang/include/clang/Basic/Module.h

public:
   }
 
   /// Is this a module partition.
   bool isModulePartition() const {
     return Kind == ModulePartitionInterface ||
            Kind == ModulePartitionImplementation;
   }
 
+  // Is this a C++20 module interface or a partition.
+  bool isInterfaceOrPartition() const {
+    return Kind == ModuleInterfaceUnit || isModulePartition();
+  }
+
   /// Get the primary module interface name from a partition.
   StringRef getPrimaryModuleInterfaceName() const {
     if (isModulePartition()) {
       auto pos = Name.find(':');
       return StringRef(Name.data(), pos);
     }
     return Name;
   }

clang/lib/Serialization/ASTWriterDecl.cpp

if (Init.getCopyExpr())
       Record.push_back(Init.canThrow());
   }
 
   if (D->getStorageDuration() == SD_Static) {
     bool ModulesCodegen = false;
     if (Writer.WritingModule &&
         !D->getDescribedVarTemplate() && !D->getMemberSpecializationInfo() &&
         !isa<VarTemplateSpecializationDecl>(D)) {
-      // When building a C++ Modules TS module interface unit, a strong
-      // definition in the module interface is provided by the compilation of
-      // that module interface unit, not by its users. (Inline variables are
-      // still emitted in module users.)
+      // When building a C++20 module interface unit or a partition unit, a
+      // strong definition in the module interface is provided by the
+      // compilation of that unit, not by its users. (Inline variables are still
+      // emitted in module users.)
       ModulesCodegen =
-          (Writer.WritingModule->Kind == Module::ModuleInterfaceUnit ||
+          (Writer.WritingModule->isInterfaceOrPartition() ||
            (D->hasAttr<DLLExportAttr>() &&
             Writer.Context->getLangOpts().BuildingPCHWithObjectFile)) &&
           Writer.Context->GetGVALinkageForVariable(D) == GVA_StrongExternal;
     }
     Record.push_back(ModulesCodegen);
     if (ModulesCodegen)
       Writer.ModularCodegenDecls.push_back(Writer.GetDeclRef(D));
   }
void ASTRecordWriter::AddFunctionDefinition(const FunctionDecl *FD) {
   // Switch case IDs are per function body.
   Writer->ClearSwitchCaseIDs();
 
   assert(FD->doesThisDeclarationHaveABody());
   bool ModulesCodegen = false;
   if (!FD->isDependentContext()) {
     Optional<GVALinkage> Linkage;
     if (Writer->WritingModule &&
-        Writer->WritingModule->Kind == Module::ModuleInterfaceUnit) {
-      // When building a C++ Modules TS module interface unit, a strong
-      // definition in the module interface is provided by the compilation of
-      // that module interface unit, not by its users. (Inline functions are
-      // still emitted in module users.)
+        Writer->WritingModule->isInterfaceOrPartition()) {
+      // When building a C++20 module interface unit or a partition unit, a
+      // strong definition in the module interface is provided by the
+      // compilation of that unit, not by its users. (Inline functions are still
+      // emitted in module users.)
       Linkage = Writer->Context->GetGVALinkageForFunction(FD);
       ModulesCodegen = *Linkage == GVA_StrongExternal;
     }
     if (Writer->Context->getLangOpts().ModulesCodegen ||
         (FD->hasAttr<DLLExportAttr>() &&
          Writer->Context->getLangOpts().BuildingPCHWithObjectFile)) {
 
       // Under -fmodules-codegen, codegen is performed for all non-internal,

clang/test/CodeGenCXX/partitions.cpp

+// RUN: rm -rf %t
+// RUN: mkdir %t
+// RUN: split-file %s %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/parta.cppm -o %t/mod-parta.pcm
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/partb.cppm -o %t/mod-partb.pcm
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -fmodule-file=%t/mod-parta.pcm \
+// RUN:     -fmodule-file=%t/mod-partb.pcm %t/mod.cppm -o %t/mod.pcm
+// RUN: %clang_cc1 -std=c++20 %t/mod.pcm -S -emit-llvm -disable-llvm-passes -o - \
+// RUN:     | FileCheck %t/mod.cppm
+// RUN: %clang_cc1 -std=c++20 -O2 -emit-module-interface -fmodule-file=%t/mod-parta.pcm \
+// RUN:     -fmodule-file=%t/mod-partb.pcm %t/mod.cppm -o %t/mod.pcm
+// RUN: %clang_cc1 -std=c++20 -O2 %t/mod.pcm -S -emit-llvm -disable-llvm-passes -o - \
+// RUN:     | FileCheck %t/mod.cppm  -check-prefix=CHECK-OPT
+
+//--- parta.cppm
+export module mod:parta;
+
+export int a = 43;
+
+export int foo() {
+  return 3 + a;
+}
+
+//--- partb.cppm
+export module mod:partb;
+
+export int b = 43;
+
+export int bar() {
+  return 43 + b;
+}
+
+//--- mod.cppm
+export module mod;
+import :parta;
+import :partb;
+export int use() {
+  return foo() + bar() + a + b;
+}
+
+// CHECK: @a = available_externally global
+// CHECK: @b = available_externally global
+// CHECK: declare noundef i32 @_Z3foov
+// CHECK: declare noundef i32 @_Z3barv
+
+// CHECK-OPT: @a = available_externally global
+// CHECK-OPT: @b = available_externally global
+// CHECK-OPT: define available_externally noundef i32 @_Z3foov
+// CHECK-OPT: define available_externally noundef i32 @_Z3barv