[CMake] Add option to switch default C++ stdlib

[Hahnfeld]

Summary

With this option one can set the default library to use if no -stdlib= is provided on compiler invocation (currently hard coded libstdc++ which remains default)
Also add explicit option -stdlib=libstdc++ to tests that require it and would fail when you choose libc++.

[Hahnfeld]

Any comments on this change?

[Hahnfeld]

ping

[beanz]

Is it correct to assume that all the test case changes are needed just to make the tests pass if you set CLANG_DEFAULT_CXX_STDLIB=libc++?

I'm not really comfortable approving this patch because I've made all of one or two changes ever to the driver, but I can try to pester someone else to take a gander. It doesn't look particularly invasive to me.

One comment inline.

lib/Driver/ToolChain.cpp

552 ↗

(On Diff #44105)

There are two cases where this line would get hit:

(1) If the stdlib arg is an invalid library, it falls through here after printing the diagnostic
(2) if CLANG_DEFAULT_CXX_STDLIB is itself an invalid library value

Can you add a configure-time or compile time check to catch case 2?

[rsmith]

The direction here generally seems fine to me.

lib/Driver/ToolChain.cpp

538 ↗

(On Diff #44105)

On Darwin, this default will be clobbered by the code in Darwin::TranslateArgs in ToolChains.cpp. On MIPS, this override will take no effect because GetCXXStdlibType is overridden.

Perhaps we could instead default CLANG_DEFAULT_CXX_STDLIB to "", and let the tool chain pick the default if it's neither specified at configure time nor on the command line.

[Hahnfeld]

Address reviewers' comments:

• check for valid CLANG_DEFAULT_CXX_STDLIB
• generalize for Darwin and Bitrig by introducing GetDefaultCXXStdlibType
• fallback to CLANG_DEFAULT_CXX_STDLIB if user choice is incorrect

[Hahnfeld]

In D15920#347352, @beanz wrote:

Is it correct to assume that all the test case changes are needed just to make the tests pass if you set CLANG_DEFAULT_CXX_STDLIB=libc++?

[...]

Yes, most of the tests check for the correct libstdc++ include paths which are not met with libc++.

lib/Driver/ToolChain.cpp

549–550 ↗

(On Diff #47441)

I have moved the behaviour from Darwin::TranslateArgs to Darwin::GetDefaultCXXStdlibType and added this method for Bitrig as well (which was straightforward). MIPS only allows libc++ so there is nothing the user can choose from...

I would have also liked to implement this for FreeBSD and NetBSD but their default library is dependent on the system version. While this wouldn't be a problem and could be implemented in GetDefaultCXXStdlibType, this would still be overriden by CLANG_DEFAULT_CXX_STDLIB which unfortunately fails the tests in test/Driver/{freebsd.c,netbsd.c}. Is it ok to leave this for now?

[beanz]

Everything about this looks reasonable to me.

Can you commit the test changes in a separate commit before committing the other changes? That way if something goes wrong the diff for the meat of the patch is a small diff.

[Hahnfeld]

In D15920#350401, @beanz wrote:

Can you commit the test changes in a separate commit before committing the other changes? That way if something goes wrong the diff for the meat of the patch is a small diff.

Committed seperately in rL260661, thanks.

cfe/trunk/CMakeLists.txt

 
 set(C_INCLUDE_DIRS "" CACHE STRING
   "Colon separated list of directories clang will search for headers.")
 
 set(GCC_INSTALL_PREFIX "" CACHE PATH "Directory where gcc is installed." )
 set(DEFAULT_SYSROOT "" CACHE PATH
   "Default <path> to all compiler invocations for --sysroot=<path>." )
 
+set(CLANG_DEFAULT_CXX_STDLIB "" CACHE STRING
+  "Default C++ stdlib to use (empty for architecture default, \"libstdc++\" or \"libc++\"")
+if (NOT(CLANG_DEFAULT_CXX_STDLIB STREQUAL "" OR
+        CLANG_DEFAULT_CXX_STDLIB STREQUAL "libstdc++" OR
+        CLANG_DEFAULT_CXX_STDLIB STREQUAL "libc++"))
+  message(WARNING "Resetting default C++ stdlib to use architecture default")
+  set(CLANG_DEFAULT_CXX_STDLIB "")
+endif()
+
 set(CLANG_DEFAULT_OPENMP_RUNTIME "libomp" CACHE STRING
   "Default OpenMP runtime used by -fopenmp.")
 
 set(CLANG_VENDOR "" CACHE STRING
   "Vendor-specific text for showing with version information.")
 
 if( CLANG_VENDOR )
   add_definitions( -DCLANG_VENDOR="${CLANG_VENDOR} " )

cfe/trunk/include/clang/Config/config.h.cmake

 /* This generated file is for internal use. Do not include it from headers. */
 
 #ifdef CLANG_CONFIG_H
 #error config.h can only be included once
 #else
 #define CLANG_CONFIG_H
 
 /* Bug report URL. */
 #define BUG_REPORT_URL "${BUG_REPORT_URL}"
 
+/* Default C++ stdlib to use. */
+#define CLANG_DEFAULT_CXX_STDLIB "${CLANG_DEFAULT_CXX_STDLIB}"
+
 /* Default OpenMP runtime used by -fopenmp. */
 #define CLANG_DEFAULT_OPENMP_RUNTIME "${CLANG_DEFAULT_OPENMP_RUNTIME}"
 
 /* Multilib suffix for libdir. */
 #define CLANG_LIBDIR_SUFFIX "${CLANG_LIBDIR_SUFFIX}"
 
 /* Relative directory for resource files */
 #define CLANG_RESOURCE_DIR "${CLANG_RESOURCE_DIR}"

cfe/trunk/include/clang/Config/config.h.in

 /* This generated file is for internal use. Do not include it from headers. */
 
 #ifdef CLANG_CONFIG_H
 #error config.h can only be included once
 #else
 #define CLANG_CONFIG_H
 
 /* Bug report URL. */
 #undef BUG_REPORT_URL
 
+/* Default C++ stdlib to use. */
+#undef CLANG_DEFAULT_CXX_STDLIB
+
 /* Default OpenMP runtime used by -fopenmp. */
 #undef CLANG_DEFAULT_OPENMP_RUNTIME
 
 /* Multilib suffix for libdir. */
 #undef CLANG_LIBDIR_SUFFIX
 
 /* Relative directory for resource files */
 #undef CLANG_RESOURCE_DIR

cfe/trunk/include/clang/Driver/ToolChain.h

virtual unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const {
     return 0;
   }
 
   /// GetDefaultRuntimeLibType - Get the default runtime library variant to use.
   virtual RuntimeLibType GetDefaultRuntimeLibType() const {
     return ToolChain::RLT_Libgcc;
   }
 
+  virtual CXXStdlibType GetDefaultCXXStdlibType() const {
+    return ToolChain::CST_Libstdcxx;
+  }
+
   virtual std::string getCompilerRT(const llvm::opt::ArgList &Args,
                                     StringRef Component,
                                     bool Shared = false) const;
 
   const char *getCompilerRTArgString(const llvm::opt::ArgList &Args,
                                      StringRef Component,
                                      bool Shared = false) const;
   /// needsProfileRT - returns true if instrumentation profile is on.

cfe/trunk/lib/Driver/ToolChain.cpp

 //===--- ToolChain.cpp - Collections of tools for one platform ------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Tools.h"
 #include "clang/Basic/ObjCRuntime.h"
+#include "clang/Config/config.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Driver.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "clang/Driver/ToolChain.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
if (Value == "libgcc")
       return ToolChain::RLT_Libgcc;
     getDriver().Diag(diag::err_drv_invalid_rtlib_name)
       << A->getAsString(Args);
   }
 
   return GetDefaultRuntimeLibType();
 }
 
+static bool ParseCXXStdlibType(const StringRef& Name,
+                               ToolChain::CXXStdlibType& Type) {
+  if (Name == "libc++")
+    Type = ToolChain::CST_Libcxx;
+  else if (Name == "libstdc++")
+    Type = ToolChain::CST_Libstdcxx;
+  else
+    return false;
+
+  return true;
+}
+
 ToolChain::CXXStdlibType ToolChain::GetCXXStdlibType(const ArgList &Args) const{
-  if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
-    StringRef Value = A->getValue();
-    if (Value == "libc++")
-      return ToolChain::CST_Libcxx;
-    if (Value == "libstdc++")
-      return ToolChain::CST_Libstdcxx;
+  ToolChain::CXXStdlibType Type;
+  bool HasValidType = false;
+
+  const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
+  if (A) {
+    HasValidType = ParseCXXStdlibType(A->getValue(), Type);
+    if (!HasValidType)
       getDriver().Diag(diag::err_drv_invalid_stdlib_name)
         << A->getAsString(Args);
   }
 
-  return ToolChain::CST_Libstdcxx;
+  if (!HasValidType && !ParseCXXStdlibType(CLANG_DEFAULT_CXX_STDLIB, Type))
+    Type = GetDefaultCXXStdlibType();
+
+  return Type;
 }
 
 /// \brief Utility function to add a system include directory to CC1 arguments.
 /*static*/ void ToolChain::addSystemInclude(const ArgList &DriverArgs,
                                             ArgStringList &CC1Args,
                                             const Twine &Path) {
   CC1Args.push_back("-internal-isystem");
   CC1Args.push_back(DriverArgs.MakeArgString(Path));

cfe/trunk/lib/Driver/ToolChains.h

public:
   // most development is done against SDKs, so compiling for a different
   // architecture should not get any special treatment.
   bool isCrossCompiling() const override { return false; }
 
   llvm::opt::DerivedArgList *
   TranslateArgs(const llvm::opt::DerivedArgList &Args,
                 const char *BoundArch) const override;
 
+  CXXStdlibType GetDefaultCXXStdlibType() const override;
   ObjCRuntime getDefaultObjCRuntime(bool isNonFragile) const override;
   bool hasBlocksRuntime() const override;
 
   bool UseObjCMixedDispatch() const override {
     // This is only used with the non-fragile ABI and non-legacy dispatch.
 
     // Mixed dispatch is used everywhere except OS X before 10.6.
     return !(isTargetMacOS() && isMacosxVersionLT(10, 6));

 class LLVM_LIBRARY_VISIBILITY Bitrig : public Generic_ELF {
 public:
   Bitrig(const Driver &D, const llvm::Triple &Triple,
          const llvm::opt::ArgList &Args);
 
   bool IsMathErrnoDefault() const override { return false; }
   bool IsObjCNonFragileABIDefault() const override { return true; }
 
-  CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
+  CXXStdlibType GetDefaultCXXStdlibType() const override;
   void AddClangCXXStdlibIncludeArgs(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const override;
   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
     return 1;
   }

cfe/trunk/lib/Driver/ToolChains.cpp

types::ID MachO::LookupTypeForExtension(const char *Ext) const {
   if (Ty == types::TY_PP_Asm)
     return types::TY_Asm;
 
   return Ty;
 }
 
 bool MachO::HasNativeLLVMSupport() const { return true; }
 
+ToolChain::CXXStdlibType Darwin::GetDefaultCXXStdlibType() const {
+  // Default to use libc++ on OS X 10.9+ and iOS 7+.
+  if ((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
+       (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
+       isTargetWatchOSBased())
+    return ToolChain::CST_Libcxx;
+
+  return ToolChain::CST_Libstdcxx;
+}
+
 /// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0.
 ObjCRuntime Darwin::getDefaultObjCRuntime(bool isNonFragile) const {
   if (isTargetWatchOSBased())
     return ObjCRuntime(ObjCRuntime::WatchOS, TargetVersion);
   if (isTargetIOSBased())
     return ObjCRuntime(ObjCRuntime::iOS, TargetVersion);
   if (isNonFragile)
     return ObjCRuntime(ObjCRuntime::MacOSX, TargetVersion);
void MachO::AddLinkRuntimeLibArgs(const ArgList &Args,
 
   AddLinkRuntimeLib(Args, CmdArgs, CompilerRT, false, true);
 }
 
 DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args,
                                       const char *BoundArch) const {
   // First get the generic Apple args, before moving onto Darwin-specific ones.
   DerivedArgList *DAL = MachO::TranslateArgs(Args, BoundArch);
-  const OptTable &Opts = getDriver().getOpts();
 
   // If no architecture is bound, none of the translations here are relevant.
   if (!BoundArch)
     return DAL;
 
   // Add an explicit version min argument for the deployment target. We do this
   // after argument translation because -Xarch_ arguments may add a version min
   // argument.
for (ArgList::iterator it = DAL->begin(), ie = DAL->end(); it != ie; ) {
       assert(it != ie && "unexpected argument translation");
       A = *it;
       assert(A->getOption().getID() == options::OPT_static &&
              "missing expected -static argument");
       it = DAL->getArgs().erase(it);
     }
   }
 
-  // Default to use libc++ on OS X 10.9+ and iOS 7+.
-  if (((isTargetMacOS() && !isMacosxVersionLT(10, 9)) ||
-       (isTargetIOSBased() && !isIPhoneOSVersionLT(7, 0)) ||
-       isTargetWatchOSBased()) &&
-      !Args.getLastArg(options::OPT_stdlib_EQ))
-    DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_stdlib_EQ),
-                      "libc++");
-
   // Validate the C++ standard library choice.
   CXXStdlibType Type = GetCXXStdlibType(*DAL);
   if (Type == ToolChain::CST_Libcxx) {
     // Check whether the target provides libc++.
     StringRef where;
 
     // Complain about targeting iOS < 5.0 in any way.
     if (isTargetIOSBased() && isIPhoneOSVersionLT(5, 0))

 }
 
 Tool *Bitrig::buildAssembler() const {
   return new tools::bitrig::Assembler(*this);
 }
 
 Tool *Bitrig::buildLinker() const { return new tools::bitrig::Linker(*this); }
 
-ToolChain::CXXStdlibType Bitrig::GetCXXStdlibType(const ArgList &Args) const {
-  if (Arg *A = Args.getLastArg(options::OPT_stdlib_EQ)) {
-    StringRef Value = A->getValue();
-    if (Value == "libstdc++")
-      return ToolChain::CST_Libstdcxx;
-    if (Value == "libc++")
-      return ToolChain::CST_Libcxx;
-
-    getDriver().Diag(diag::err_drv_invalid_stdlib_name) << A->getAsString(Args);
-  }
+ToolChain::CXXStdlibType Bitrig::GetDefaultCXXStdlibType() const {
   return ToolChain::CST_Libcxx;
 }
 
 void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
                                           ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
       DriverArgs.hasArg(options::OPT_nostdincxx))
     return;