Allow static linking of libc++ on Linux, just like -static-libstdc++

[erikjv]

Summary

Dynamic linking against libc++ on Linux was already supported, as is
dynamic and static linking against libstdc++. What was missing is being
able to statically link against libc++. This can be used by applications
that choose to use libc++ instead of libstdc++, but do not (or can not)
require the dynamic libraries of libc++(abi) to be installed.

[lebedev.ri]

Tests?

[erikjv]

In D63329#1543407, @lebedev.ri wrote:

Tests?

I'll add a test along the lines of "test/Driver/fuchsia.cpp" line 36, where it tests "-static-libstdc++".

For the short discussion we had on IRC: there currently is no real protection on mixing things like -stdlib=libc++ and -static-libstdc++ in the linker command-line, other than the linker complaining about missing symbols. I've been looking at the drivers, but I'm not sure in which Tool subclass to put the check.

[hfinkel]

clang/lib/Driver/ToolChains/Gnu.cpp

570

Why does this say FIXME?

574

It seems to me that, in general, the answer will be yes. std::thread is built on pthreads, generally, and if we need to change this for particular systems, then that can always be done as a special case.

[bryanpkc]

@erikjv Are you still working on this? Or is a better alternative being pursued? IIUC, this functionality is still missing in trunk.

[zixuan-wu]

Is this going to continue?
And also if we use libunwind to handle EH, then it uses dladdr function which need link libdl.

clang/include/clang/Driver/Options.td

 def segs__read__ : Joined<["-"], "segs_read_">;
 def shared_libgcc : Flag<["-"], "shared-libgcc">;
 def shared : Flag<["-", "--"], "shared">;
 def single__module : Flag<["-"], "single_module">;
 def specs_EQ : Joined<["-", "--"], "specs=">;
 def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
 def static_libgcc : Flag<["-"], "static-libgcc">;
 def static_libstdcxx : Flag<["-"], "static-libstdc++">;
+def static_libcxx : Flag<["-"], "static-libc++">;
 def static : Flag<["-", "--"], "static">, Flags<[NoArgumentUnused]>;
 def std_default_EQ : Joined<["-"], "std-default=">;
 def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
   Group<CompileOnly_Group>, HelpText<"Language standard to compile for">,
   ValuesCode<[{
     const char *Values =
     #define LANGSTANDARD(id, name, lang, desc, features) name ","
     #define LANGSTANDARD_ALIAS(id, alias) alias ","

clang/lib/Driver/ToolChains/Gnu.cpp

void tools::gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   bool NeedsXRayDeps = addXRayRuntime(ToolChain, Args, CmdArgs);
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
   // The profile runtime also needs access to system libraries.
   getToolChain().addProfileRTLibs(Args, CmdArgs);
 
   if (D.CCCIsCXX() &&
       !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     if (ToolChain.ShouldLinkCXXStdlib(Args)) {
-      bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
+      bool OnlyLibstdcxxStatic = (Args.hasArg(options::OPT_static_libstdcxx) ||
+                                  Args.hasArg(options::OPT_static_libcxx)) &&
                                  !Args.hasArg(options::OPT_static);
       if (OnlyLibstdcxxStatic)
         CmdArgs.push_back("-Bstatic");
       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
+      if (Args.hasArg(options::OPT_static_libcxx)) // libc++ links against libc++abi, so we have to pull that in too.
+        CmdArgs.push_back("-lc++abi");
       if (OnlyLibstdcxxStatic)
         CmdArgs.push_back("-Bdynamic");
     }
     CmdArgs.push_back("-lm");
   }
   // Silence warnings when linking C code with a C++ '-stdlib' argument.
   Args.ClaimAllArgs(options::OPT_stdlib_EQ);
 
if (!Args.hasArg(options::OPT_nodefaultlibs)) {
       // require librt. Most modern Linux platforms do, but some may not.
       if (addOpenMPRuntime(CmdArgs, ToolChain, Args,
                            JA.isHostOffloading(Action::OFK_OpenMP),
                            /* GompNeedsRT= */ true))
         // OpenMP runtimes implies pthreads when using the GNU toolchain.
         // FIXME: Does this really make sense for all GNU toolchains?
         WantPthread = true;
 
+      // FIXME: libc++ dynamically links against libpthread, so for static
+      // linking, we need to supply that dependency.
+      if (Args.hasArg(options::OPT_static_libcxx))
+        // FIXME: Again, like above, does this really make sense for all GNU
+        // toolchains?
+        WantPthread = true;
+
       AddRunTimeLibs(ToolChain, D, CmdArgs, Args);
 
       if (WantPthread && !isAndroid)
         CmdArgs.push_back("-lpthread");
 
       if (Args.hasArg(options::OPT_fsplit_stack))
         CmdArgs.push_back("--wrap=pthread_create");