[cxx-interop] Allow compiling with libc++ on Linux

This makes sure that Swift respects `-Xcc -stdlib=libc++` flags.

Clang already has existing logic to discover the system-wide libc++ installation on Linux. We rely on that logic here.

Importing a Swift module that was built with a different C++ stdlib is not supported and emits an error.

The Cxx module can be imported when compiling with any C++ stdlib. The synthesized conformances, e.g. to CxxRandomAccessCollection also work. However, CxxStdlib currently cannot be imported when compiling with libc++, since on Linux it refers to symbols from libstdc++ which have different mangled names in libc++.

rdar://118357548 / #69825

Author: egorzhdan

include/swift/AST/Decl.h

@@ -722,7 +722,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     HasAnyUnavailableDuringLoweringValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1,
     /// If the module is compiled as static library.
     StaticLibrary : 1,
 
@@ -780,6 +780,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     /// Whether this module has been built with C++ interoperability enabled.
     HasCxxInteroperability : 1,
 
+    /// Whether this module uses the platform default C++ stdlib, or an
+    /// overridden C++ stdlib.
+    CXXStdlibKind : 1,
+
     /// Whether this module has been built with -allow-non-resilient-access.
     AllowNonResilientAccess : 1,
 

include/swift/AST/DiagnosticEngine.h

@@ -50,6 +50,7 @@ namespace swift {
   class ValueDecl;
   class SourceFile;
 
+  enum class CXXStdlibKind : uint8_t;
   enum class DescriptivePatternKind : uint8_t;
   enum class SelfAccessKind : uint8_t;
   enum class ReferenceOwnership : uint8_t;

include/swift/AST/DiagnosticsSema.def

@@ -942,6 +942,13 @@ ERROR(need_cxx_interop_to_import_module,none,
 NOTE(enable_cxx_interop_docs,none,
      "visit https://www.swift.org/documentation/cxx-interop/project-build-setup to learn how to enable C++ interoperability", ())
 
+ERROR(cxx_stdlib_kind_mismatch,none,
+      "module %0 was built with "
+      "%select{platform default C++ stdlib|libc++}1, "
+      "but current compilation uses "
+      "%select{platform default C++ stdlib|libc++}2",
+      (Identifier, CXXStdlibKind, CXXStdlibKind))
+
 ERROR(modularization_issue_decl_moved,Fatal,
       "reference to %select{top-level declaration|type}0 %1 broken by a context change; "
       "%1 was expected to be in %2, but now a candidate is found only in %3",

include/swift/AST/Module.h

@@ -27,6 +27,7 @@
 #include "swift/AST/Type.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/BasicSourceInfo.h"
+#include "swift/Basic/CXXStdlibKind.h"
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/OptionSet.h"
@@ -705,6 +706,13 @@ class ModuleDecl
     Bits.ModuleDecl.HasCxxInteroperability = enabled;
   }
 
+  CXXStdlibKind getCXXStdlibKind() const {
+    return static_cast<CXXStdlibKind>(Bits.ModuleDecl.CXXStdlibKind);
+  }
+  void setCXXStdlibKind(CXXStdlibKind kind) {
+    Bits.ModuleDecl.CXXStdlibKind = static_cast<uint8_t>(kind);
+  }
+
   /// \returns true if this module is a system module; note that the StdLib is
   /// considered a system module.
   bool isSystemModule() const {

include/swift/AST/ModuleDependencies.h

@@ -21,6 +21,7 @@
 #include "swift/AST/Import.h"
 #include "swift/AST/LinkLibrary.h"
 #include "swift/AST/SearchPathOptions.h"
+#include "swift/Basic/CXXStdlibKind.h"
 #include "swift/Basic/LLVM.h"
 #include "clang/CAS/CASOptions.h"
 #include "clang/Tooling/DependencyScanning/DependencyScanningService.h"
@@ -135,7 +136,7 @@ void registerBackDeployLibraries(
     std::function<void(const LinkLibrary &)> RegistrationCallback);
 void registerCxxInteropLibraries(
     const llvm::Triple &Target, StringRef mainModuleName, bool hasStaticCxx,
-    bool hasStaticCxxStdlib,
+    bool hasStaticCxxStdlib, CXXStdlibKind cxxStdlibKind,
     std::function<void(const LinkLibrary &)> RegistrationCallback);
 } // namespace dependencies
 

include/swift/Basic/CXXStdlibKind.h

@@ -0,0 +1,30 @@
+//===--- CXXStdlibKind.h ----------------------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_BASIC_CXX_STDLIB_KIND_H
+#define SWIFT_BASIC_CXX_STDLIB_KIND_H
+
+namespace swift {
+
+enum class CXXStdlibKind : uint8_t {
+  /// Use the default C++ stdlib for a particular platform: libc++ for Darwin,
+  /// libstdc++ for most Linux distros.
+  PlatformDefault = 0,
+
+  /// Use libc++ instead of the default C++ stdlib on a platform where libc++
+  /// is not the default, e.g. Ubuntu.
+  OverrideLibcxx = 1,
+};
+
+} // namespace swift
+
+#endif // SWIFT_BASIC_CXX_STDLIB_KIND_H

include/swift/Basic/LangOptions.h

@@ -19,6 +19,7 @@
 #define SWIFT_BASIC_LANGOPTIONS_H
 
 #include "swift/AST/DiagnosticsFrontend.h"
+#include "swift/Basic/CXXStdlibKind.h"
 #include "swift/Basic/Feature.h"
 #include "swift/Basic/FixedBitSet.h"
 #include "swift/Basic/FunctionBodySkipping.h"
@@ -321,6 +322,8 @@ namespace swift {
     void setCxxInteropFromArgs(llvm::opt::ArgList &Args,
                                swift::DiagnosticEngine &Diags);
 
+    CXXStdlibKind CXXStdlib = CXXStdlibKind::PlatformDefault;
+
     bool CForeignReferenceTypes = false;
 
     /// Imports getters and setters as computed properties.

include/swift/Serialization/Validation.h

@@ -14,6 +14,7 @@
 #define SWIFT_SERIALIZATION_VALIDATION_H
 
 #include "swift/AST/Identifier.h"
+#include "swift/Basic/CXXStdlibKind.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Version.h"
 #include "swift/Serialization/SerializationOptions.h"
@@ -141,6 +142,7 @@ class ExtendedValidationInfo {
     unsigned IsAllowModuleWithCompilerErrorsEnabled : 1;
     unsigned IsConcurrencyChecked : 1;
     unsigned HasCxxInteroperability : 1;
+    unsigned CXXStdlibKind : 1;
     unsigned AllowNonResilientAccess: 1;
     unsigned SerializePackageEnabled: 1;
   } Bits;
@@ -241,6 +243,13 @@ class ExtendedValidationInfo {
   void setHasCxxInteroperability(bool val) {
     Bits.HasCxxInteroperability = val;
   }
+
+  CXXStdlibKind getCXXStdlibKind() const {
+    return static_cast<CXXStdlibKind>(Bits.CXXStdlibKind);
+  }
+  void setCXXStdlibKind(CXXStdlibKind kind) {
+    Bits.CXXStdlibKind = static_cast<uint8_t>(kind);
+  }
 };
 
 struct SearchPath {

lib/AST/Module.cpp

@@ -725,6 +725,7 @@ ModuleDecl::ModuleDecl(Identifier name, ASTContext &ctx,
   Bits.ModuleDecl.IsConcurrencyChecked = 0;
   Bits.ModuleDecl.ObjCNameLookupCachePopulated = 0;
   Bits.ModuleDecl.HasCxxInteroperability = 0;
+  Bits.ModuleDecl.CXXStdlibKind = 0;
   Bits.ModuleDecl.AllowNonResilientAccess = 0;
   Bits.ModuleDecl.SerializePackageEnabled = 0;
 }

lib/AST/ModuleDependencies.cpp

@@ -540,9 +540,9 @@ void
 swift::dependencies::registerCxxInteropLibraries(
     const llvm::Triple &Target,
     StringRef mainModuleName,
-    bool hasStaticCxx, bool hasStaticCxxStdlib,
+    bool hasStaticCxx, bool hasStaticCxxStdlib, CXXStdlibKind cxxStdlibKind,
     std::function<void(const LinkLibrary&)> RegistrationCallback) {
-  if (Target.isOSDarwin())
+  if (Target.isOSDarwin() || cxxStdlibKind == CXXStdlibKind::OverrideLibcxx)
     RegistrationCallback(LinkLibrary("c++", LibraryKind::Library));
   else if (Target.isOSLinux())
     RegistrationCallback(LinkLibrary("stdc++", LibraryKind::Library));

lib/AST/ModuleLoader.cpp

@@ -172,6 +172,13 @@ void ModuleLoader::findOverlayFiles(SourceLoc diagLoc, ModuleDecl *module,
   using namespace llvm::sys;
   using namespace file_types;
 
+  // If an overlay for CxxStdlib was requested, only proceed if compiling with
+  // the platform-default C++ stdlib.
+  if (module->getName() == module->getASTContext().Id_CxxStdlib &&
+      module->getASTContext().LangOpts.CXXStdlib !=
+          CXXStdlibKind::PlatformDefault)
+    return;
+
   // If cross import information is passed on command-line, prefer use that.
   auto &crossImports = module->getASTContext().SearchPathOpts.CrossImportInfo;
   auto overlays = crossImports.find(module->getNameStr());

lib/ClangImporter/ClangImporter.cpp

@@ -4298,8 +4298,10 @@ ModuleDecl *ClangModuleUnit::getOverlayModule() const {
     }
     // If this Clang module is a part of the C++ stdlib, and we haven't loaded
     // the overlay for it so far, it is a split libc++ module (e.g. std_vector).
-    // Load the CxxStdlib overlay explicitly.
-    if (!overlay && importer::isCxxStdModule(clangModule)) {
+    // Load the CxxStdlib overlay explicitly, if building with the
+    // platform-default C++ stdlib.
+    if (!overlay && importer::isCxxStdModule(clangModule) &&
+        Ctx.LangOpts.CXXStdlib == CXXStdlibKind::PlatformDefault) {
       ImportPath::Module::Builder builder(Ctx.Id_CxxStdlib);
       overlay = owner.loadModule(SourceLoc(), std::move(builder).get());
     }

lib/ClangImporter/ClangIncludePaths.cpp

@@ -256,6 +256,10 @@ static void getLibStdCxxFileMapping(
   if (triple.isAndroid()
       || (triple.isMusl() && triple.getVendor() == llvm::Triple::Swift))
     return;
+  // Make sure we are building with libstdc++. On platforms where libstdc++ is
+  // the default C++ stdlib, users can still compile with `-Xcc -stdlib=libc++`.
+  if (ctx.LangOpts.CXXStdlib == CXXStdlibKind::OverrideLibcxx)
+    return;
 
   // Extract the libstdc++ installation path from Clang driver.
   auto clangDriver = createClangDriver(ctx, vfs);

lib/DependencyScan/ScanDependencies.cpp

@@ -1429,7 +1429,8 @@ static void resolveImplicitLinkLibraries(const CompilerInstance &instance,
     bool hasStaticCxxStdlib = OptionalCxxStdLibDep.has_value() &&
                               OptionalCxxStdLibDep.value()->isStaticLibrary();
     registerCxxInteropLibraries(langOpts.Target, mainModuleName, hasStaticCxx,
-                                hasStaticCxxStdlib, addLinkLibrary);
+                                hasStaticCxxStdlib, langOpts.CXXStdlib,
+                                addLinkLibrary);
   }
 
   if (!irGenOpts.UseJIT && !langOpts.hasFeature(Feature::Embedded))

lib/Frontend/CompilerInvocation.cpp

@@ -627,6 +627,16 @@ void LangOptions::setCxxInteropFromArgs(ArgList &Args,
       cxxInteropCompatVersion =
           validateCxxInteropCompatibilityMode("swift-5.9").second;
   }
+
+  for (const Arg *A : Args.filtered(options::OPT_Xcc)) {
+    StringRef clangArg = A->getValue();
+    if (clangArg.consume_front("-stdlib")) {
+      clangArg.consume_front("=");
+      if (clangArg.equals("libc++") && Target.isOSLinux())
+        CXXStdlib = CXXStdlibKind::OverrideLibcxx;
+      // If the stdlib argument is invalid, Clang will emit an error.
+    }
+  }
 }
 
 static std::optional<swift::StrictConcurrency>

lib/Frontend/Frontend.cpp

@@ -1465,6 +1465,8 @@ ModuleDecl *CompilerInstance::getMainModule() const {
     if (Invocation.getLangOptions().EnableCXXInterop &&
         Invocation.getLangOptions().RequireCxxInteropToImportCxxInteropModule)
       MainModule->setHasCxxInteroperability();
+    if (Invocation.getLangOptions().EnableCXXInterop)
+      MainModule->setCXXStdlibKind(Invocation.getLangOptions().CXXStdlib);
     if (Invocation.getLangOptions().AllowNonResilientAccess)
       MainModule->setAllowNonResilientAccess();
     if (Invocation.getSILOptions().EnableSerializePackage)

lib/IRGen/IRGenModule.cpp

@@ -1646,6 +1646,7 @@ void IRGenModule::addLinkLibraries() {
                                               getSwiftModule()->getName().str(),
                                               hasStaticCxx,
                                               hasStaticCxxStdlib,
+                                              Context.LangOpts.CXXStdlib,
                                               registerLinkLibrary);
   }
 

lib/Serialization/ModuleFile.h

@@ -642,6 +642,11 @@ class ModuleFile
     return Core->Bits.HasCxxInteroperability;
   }
 
+  /// The kind of the C++ stdlib that this module was built with.
+  CXXStdlibKind getCXXStdlibKind() const {
+    return static_cast<CXXStdlibKind>(Core->Bits.CXXStdlibKind);
+  }
+
   /// Whether the module is resilient. ('-enable-library-evolution')
   ResilienceStrategy getResilienceStrategy() const {
     return ResilienceStrategy(Core->Bits.ResilienceStrategy);

lib/Serialization/ModuleFileSharedCore.cpp

@@ -198,6 +198,11 @@ static bool readOptionsBlock(llvm::BitstreamCursor &cursor,
     case options_block::HAS_CXX_INTEROPERABILITY_ENABLED:
       extendedInfo.setHasCxxInteroperability(true);
       break;
+    case options_block::CXX_STDLIB_KIND:
+      unsigned rawKind;
+      options_block::CXXStdlibKindLayout::readRecord(scratch, rawKind);
+      extendedInfo.setCXXStdlibKind(static_cast<CXXStdlibKind>(rawKind));
+      break;
     case options_block::ALLOW_NON_RESILIENT_ACCESS:
       extendedInfo.setAllowNonResilientAccess(true);
       break;
@@ -1461,6 +1466,7 @@ ModuleFileSharedCore::ModuleFileSharedCore(
           extInfo.isAllowModuleWithCompilerErrorsEnabled();
       Bits.IsConcurrencyChecked = extInfo.isConcurrencyChecked();
       Bits.HasCxxInteroperability = extInfo.hasCxxInteroperability();
+      Bits.CXXStdlibKind = static_cast<uint8_t>(extInfo.getCXXStdlibKind());
       Bits.AllowNonResilientAccess = extInfo.allowNonResilientAccess();
       Bits.SerializePackageEnabled = extInfo.serializePackageEnabled();
       MiscVersion = info.miscVersion;

lib/Serialization/ModuleFileSharedCore.h

@@ -391,6 +391,10 @@ class ModuleFileSharedCore {
     /// Whether this module is built with C++ interoperability enabled.
     unsigned HasCxxInteroperability : 1;
 
+    /// Whether this module uses the platform default C++ stdlib, or an
+    /// overridden C++ stdlib.
+    unsigned CXXStdlibKind : 1;
+
     /// Whether this module is built with -allow-non-resilient-access.
     unsigned AllowNonResilientAccess : 1;
 

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 881; // Changes to LifetimeDependence
+const uint16_t SWIFTMODULE_VERSION_MINOR = 882; // CXXStdlibKind
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -949,6 +949,7 @@ namespace options_block {
     HAS_CXX_INTEROPERABILITY_ENABLED,
     ALLOW_NON_RESILIENT_ACCESS,
     SERIALIZE_PACKAGE_ENABLED,
+    CXX_STDLIB_KIND,
   };
 
   using SDKPathLayout = BCRecordLayout<
@@ -1032,6 +1033,11 @@ namespace options_block {
     HAS_CXX_INTEROPERABILITY_ENABLED
   >;
 
+  using CXXStdlibKindLayout = BCRecordLayout<
+    CXX_STDLIB_KIND,
+    BCFixed<1>
+  >;
+
   using AllowNonResilientAccess = BCRecordLayout<
     ALLOW_NON_RESILIENT_ACCESS
   >;

lib/Serialization/Serialization.cpp

@@ -853,6 +853,7 @@ void Serializer::writeBlockInfoBlock() {
   BLOCK_RECORD(options_block, MODULE_ABI_NAME);
   BLOCK_RECORD(options_block, IS_CONCURRENCY_CHECKED);
   BLOCK_RECORD(options_block, HAS_CXX_INTEROPERABILITY_ENABLED);
+  BLOCK_RECORD(options_block, CXX_STDLIB_KIND);
   BLOCK_RECORD(options_block, MODULE_PACKAGE_NAME);
   BLOCK_RECORD(options_block, MODULE_EXPORT_AS_NAME);
   BLOCK_RECORD(options_block, PLUGIN_SEARCH_OPTION);
@@ -1134,6 +1135,10 @@ void Serializer::writeHeader() {
         options_block::HasCxxInteroperabilityEnabledLayout
             CxxInteroperabilityEnabled(Out);
         CxxInteroperabilityEnabled.emit(ScratchRecord);
+
+        options_block::CXXStdlibKindLayout CXXStdlibKind(Out);
+        CXXStdlibKind.emit(ScratchRecord,
+                           static_cast<uint8_t>(M->getCXXStdlibKind()));
       }
 
       if (Options.SerializeOptionsForDebugging) {

lib/Serialization/SerializedModuleLoader.cpp

@@ -954,8 +954,10 @@ LoadedFile *SerializedModuleLoaderBase::loadAST(
       M.setABIName(Ctx.getIdentifier(loadedModuleFile->getModuleABIName()));
     if (loadedModuleFile->isConcurrencyChecked())
       M.setIsConcurrencyChecked();
-    if (loadedModuleFile->hasCxxInteroperability())
+    if (loadedModuleFile->hasCxxInteroperability()) {
       M.setHasCxxInteroperability();
+      M.setCXXStdlibKind(loadedModuleFile->getCXXStdlibKind());
+    }
     if (!loadedModuleFile->getModulePackageName().empty()) {
       M.setPackageName(Ctx.getIdentifier(loadedModuleFile->getModulePackageName()));
     }
@@ -1055,6 +1057,17 @@ LoadedFile *SerializedModuleLoaderBase::loadAST(
                        M.getName());
     Ctx.Diags.diagnose(loc, diag::enable_cxx_interop_docs);
   }
+  // Modules built with libc++ cannot be imported into modules that are built
+  // with libstdc++, and vice versa. Make an exception for Cxx.swiftmodule since
+  // it doesn't refer to any C++ stdlib symbols, and for CxxStdlib.swiftmodule
+  // since we skipped loading the overlay for the module.
+  if (M.hasCxxInteroperability() && Ctx.LangOpts.EnableCXXInterop &&
+      M.getCXXStdlibKind() != Ctx.LangOpts.CXXStdlib &&
+      M.getName() != Ctx.Id_Cxx && M.getName() != Ctx.Id_CxxStdlib) {
+    auto loc = diagLoc.value_or(SourceLoc());
+    Ctx.Diags.diagnose(loc, diag::cxx_stdlib_kind_mismatch, M.getName(),
+                       M.getCXXStdlibKind(), Ctx.LangOpts.CXXStdlib);
+  }
 
   return fileUnit;
 }

test/Interop/Cxx/stdlib/unsupported-stdlib.swift

@@ -0,0 +1,3 @@
+// RUN: not %target-swift-frontend -typecheck -Xcc -stdlib=invalid -cxx-interoperability-mode=default %s 2>&1 | %FileCheck %s
+
+// CHECK: error: invalid library name in argument '-stdlib=invalid'