[Driver] Add -static= to unify -static-{libgcc,libstdc++}

[MaskRay]

Summary

We have lots of -static-* options now. Add -static= (OPT_static_EQ) so
that people can specify -static=foo,bar instead of -static-foo and
-static-bar. This saves us a bunch of OPT_static_foo, OPT_static_bar,
etc, which may be added in the future.

[MaskRay]

Rename local variables

[MaskRay]

Greeting from a dev meeting attendee :)

[martell]

Seems like a better solution than what I had in D37726.
I'm not sully sure on the naming so I think someone else should also sign off on this.

[martell]

Also, Sorry for the long time to reply, I don't LLVM often enough :)

[MaskRay]

In D53238#1318349, @martell wrote:

Seems like a better solution than what I had in D37726.
I'm not sully sure on the naming so I think someone else should also sign off on this.

This is still not good enough. --static=rtlib,stdlib may be better. I'll also find some time to improve this one :)

[rnk]

(sub)

[MaskRay]

Repurpose the patch. Add -static= instead

[pirama]

Does this regress from existing behavior for unused argument warnings? Currently, -static-libstdc++ -nostdlib issues an unused argument warning for -static-libstdc++, while AFAICT -static=c++stdlib -nostdlib doesn't.

I'm not exactly sure how/where to issue this warning, though.

[MaskRay]

In D53238#1660259, @pirama wrote:

Does this regress from existing behavior for unused argument warnings? Currently, -static-libstdc++ -nostdlib issues an unused argument warning for -static-libstdc++, while AFAICT -static=c++stdlib -nostdlib doesn't.

I'm not exactly sure how/where to issue this warning, though.

This change will suppress some unused argument warnings but I'll not call that "regression":)

Various toolchains already do things like:

Args.ClaimAllArgs(options::OPT_g_Group);
Args.ClaimAllArgs(options::OPT_emit_llvm);
Args.ClaimAllArgs(options::OPT_w);

Hexagon and Myriad even do Args.ClaimAllArgs(options::OPT_static_libgcc); This diagnostic IMO has very low value.

[Yu]

I accidentally come into this thread when searching for how to statically link to libc++/libc++abi. I'm really curious if this patch will or will not get merged. I'm really painful on using c++17 on ancient environment which does not have libc++/libc++ abi dynamic library. We have to remove -stdlib=libc++ and manually add libc++.a/libc++abi.a to the object lists. That's pretty hacky for cmake users. It'll be really awesome if we can have this patch merged. Thanks guys!

[MaskRay]

In D53238#2345618, @Yu wrote:

I accidentally come into this thread when searching for how to statically link to libc++/libc++abi. I'm really curious if this patch will or will not get merged. I'm really painful on using c++17 on ancient environment which does not have libc++/libc++ abi dynamic library. We have to remove -stdlib=libc++ and manually add libc++.a/libc++abi.a to the object lists. That's pretty hacky for cmake users. It'll be really awesome if we can have this patch merged. Thanks guys!

Though non-obvious, -static-libstdc++ actually works for -stdlib=libc++...

include/clang/Driver/Options.td

 def segs__read__only__addr : Separate<["-"], "segs_read_only_addr">;
 def segs__read__write__addr : Separate<["-"], "segs_read_write_addr">;
 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_EQ : CommaJoined<["-"], "static=">,
+                MetaVarName<"<component>">,
+                HelpText<"Link in specified components statically">;
 def static_libgcc : Flag<["-"], "static-libgcc">;
 def static_libstdcxx : Flag<["-"], "static-libstdc++">;
 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 =

include/clang/Driver/ToolChain.h

 #include "clang/Basic/DebugInfoOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Driver/Action.h"
 #include "clang/Driver/Multilib.h"
 #include "clang/Driver/Types.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Target/TargetOptions.h"
 #include <cassert>
public:
   };
 
   enum UnwindLibType {
     UNW_None,
     UNW_CompilerRT,
     UNW_Libgcc
   };
 
+  enum LibType {
+    LT_cxxstdlib,
+    LT_rtlib,
+  };
+
   enum RTTIMode {
     RM_Enabled,
     RM_Disabled,
   };
 
   enum FileType { FT_Object, FT_Static, FT_Shared };
 
 private:
private:
   Tool *getClang() const;
   Tool *getAssemble() const;
   Tool *getLink() const;
   Tool *getClangAs() const;
   Tool *getOffloadBundler() const;
 
   mutable std::unique_ptr<SanitizerArgs> SanitizerArguments;
   mutable std::unique_ptr<XRayArgs> XRayArguments;
+  mutable llvm::DenseSet<int> StaticLibs;
 
   /// The effective clang triple for the current Job.
   mutable llvm::Triple EffectiveTriple;
 
   /// Set the toolchain's effective clang triple.
   void setEffectiveTriple(llvm::Triple ET) const {
     EffectiveTriple = std::move(ET);
   }
public:
   const MultilibSet &getMultilibs() const { return Multilibs; }
 
   const Multilib &getMultilib() const { return SelectedMultilib; }
 
   const SanitizerArgs& getSanitizerArgs() const;
 
   const XRayArgs& getXRayArgs() const;
 
+  bool linksStaticLib(LibType Lib) const { return StaticLibs.count(Lib); }
+
   // Returns the Arg * that explicitly turned on/off rtti, or nullptr.
   const llvm::opt::Arg *getRTTIArg() const { return CachedRTTIArg; }
 
   // Returns the RTTIMode for the toolchain with the current arguments.
   RTTIMode getRTTIMode() const { return CachedRTTIMode; }
 
   /// Return any implicit target and/or mode flag for an invocation of
   /// the compiler driver as `ProgName`.

lib/Driver/ToolChain.cpp

ToolChain::ToolChain(const Driver &D, const llvm::Triple &T,
   }
 
   if (auto RuntimePath = getRuntimePath())
     getLibraryPaths().push_back(*RuntimePath);
 
   std::string CandidateLibPath = getArchSpecificLibPath();
   if (getVFS().exists(CandidateLibPath))
     getFilePaths().push_back(CandidateLibPath);
+
+  std::vector<StringRef> Libs;
+  for (const Arg *A : Args.filtered(options::OPT_static_EQ)) {
+    A->claim();
+    for (StringRef C : A->getValues()) {
+      if (C == "c++stdlib")
+        StaticLibs.insert(LT_cxxstdlib);
+      else if (C == "rtlib")
+        StaticLibs.insert(LT_rtlib);
+      else
+        D.Diag(diag::err_drv_unsupported_option_argument)
+            << A->getOption().getName() << C;
+    }
+  }
+
+  if (Args.hasArg(options::OPT_static))
+    for (LibType L : {LT_cxxstdlib, LT_rtlib})
+      StaticLibs.insert(L);
+  if (Args.hasArg(options::OPT_static_libstdcxx))
+    StaticLibs.insert(LT_cxxstdlib);
+  if (Args.hasArg(options::OPT_static_libgcc))
+    StaticLibs.insert(LT_rtlib);
 }
 
 void ToolChain::setTripleEnvironment(llvm::Triple::EnvironmentType Env) {
   Triple.setEnvironment(Env);
   if (EffectiveTriple != llvm::Triple())
     EffectiveTriple.setEnvironment(Env);
 }
 

lib/Driver/ToolChains/CommonArgs.cpp

 /// Determine whether Objective-C automated reference counting is
 /// enabled.
 bool tools::isObjCAutoRefCount(const ArgList &Args) {
   return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
 }
 
 enum class LibGccType { UnspecifiedLibGcc, StaticLibGcc, SharedLibGcc };
 
-static LibGccType getLibGccType(const Driver &D, const ArgList &Args) {
-  if (Args.hasArg(options::OPT_static_libgcc) ||
-      Args.hasArg(options::OPT_static) || Args.hasArg(options::OPT_static_pie))
+static LibGccType getLibGccType(const ToolChain &TC, const Driver &D,
+                                const ArgList &Args) {
+  if (TC.linksStaticLib(ToolChain::LT_rtlib) ||
+      Args.hasArg(options::OPT_static_pie))
     return LibGccType::StaticLibGcc;
   if (Args.hasArg(options::OPT_shared_libgcc) || D.CCCIsCXX())
     return LibGccType::SharedLibGcc;
   return LibGccType::UnspecifiedLibGcc;
 }
 
 // Gcc adds libgcc arguments in various ways:
 //
static void AddUnwindLibrary(const ToolChain &TC, const Driver &D,
                              ArgStringList &CmdArgs, const ArgList &Args) {
   ToolChain::UnwindLibType UNW = TC.GetUnwindLibType(Args);
   // Targets that don't use unwind libraries.
   if (TC.getTriple().isAndroid() || TC.getTriple().isOSIAMCU() ||
       TC.getTriple().isOSBinFormatWasm() ||
       UNW == ToolChain::UNW_None)
     return;
 
-  LibGccType LGT = getLibGccType(D, Args);
+  LibGccType LGT = getLibGccType(TC, D, Args);
   bool AsNeeded = LGT == LibGccType::UnspecifiedLibGcc &&
                   !TC.getTriple().isAndroid() && !TC.getTriple().isOSCygMing();
   if (AsNeeded)
     CmdArgs.push_back("--as-needed");
 
   switch (UNW) {
   case ToolChain::UNW_None:
     return;
   case ToolChain::UNW_Libgcc: {
-    LibGccType LGT = getLibGccType(D, Args);
+    LibGccType LGT = getLibGccType(TC, D, Args);
     if (LGT == LibGccType::StaticLibGcc)
       CmdArgs.push_back("-lgcc_eh");
     else
       CmdArgs.push_back("-lgcc_s");
     break;
   }
   case ToolChain::UNW_CompilerRT:
     CmdArgs.push_back("-lunwind");
     break;
   }
 
   if (AsNeeded)
     CmdArgs.push_back("--no-as-needed");
 }
 
 static void AddLibgcc(const ToolChain &TC, const Driver &D,
                       ArgStringList &CmdArgs, const ArgList &Args) {
-  LibGccType LGT = getLibGccType(D, Args);
+  LibGccType LGT = getLibGccType(TC, D, Args);
   if (LGT != LibGccType::SharedLibGcc)
     CmdArgs.push_back("-lgcc");
   AddUnwindLibrary(TC, D, CmdArgs, Args);
   if (LGT == LibGccType::SharedLibGcc)
     CmdArgs.push_back("-lgcc");
 
   // According to Android ABI, we have to link with libdl if we are
   // linking with non-static libgcc.

lib/Driver/ToolChains/CrossWindows.cpp

if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_rdynamic)) {
     CmdArgs.push_back(Args.MakeArgString(ImpLib));
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   TC.AddFilePathLibArgs(Args, CmdArgs);
   AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
 
   if (TC.ShouldLinkCXXStdlib(Args)) {
-    bool StaticCXX = Args.hasArg(options::OPT_static_libstdcxx) &&
+    bool StaticCXXStdlib = TC.linksStaticLib(ToolChain::LT_cxxstdlib) &&
                            !Args.hasArg(options::OPT_static);
-    if (StaticCXX)
+    if (StaticCXXStdlib)
       CmdArgs.push_back("-Bstatic");
     TC.AddCXXStdlibLibArgs(Args, CmdArgs);
-    if (StaticCXX)
+    if (StaticCXXStdlib)
       CmdArgs.push_back("-Bdynamic");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib)) {
     if (!Args.hasArg(options::OPT_nodefaultlibs)) {
       // TODO handle /MT[d] /MD[d]
       CmdArgs.push_back("-lmsvcrt");
       AddRunTimeLibs(TC, D, CmdArgs, Args);

lib/Driver/ToolChains/DragonFly.cpp

void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void dragonfly::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      const char *LinkingOutput) const {
-  const Driver &D = getToolChain().getDriver();
+  const ToolChain &TC = getToolChain();
+  const Driver &D = TC.getDriver();
   ArgStringList CmdArgs;
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
   CmdArgs.push_back("--eh-frame-hdr");
   if (Args.hasArg(options::OPT_static)) {
     CmdArgs.push_back("-Bstatic");
if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
 
     if (Args.hasArg(options::OPT_pthread))
       CmdArgs.push_back("-lpthread");
 
     if (!Args.hasArg(options::OPT_nolibc)) {
       CmdArgs.push_back("-lc");
     }
 
-    if (Args.hasArg(options::OPT_static) ||
-        Args.hasArg(options::OPT_static_libgcc)) {
-        CmdArgs.push_back("-lgcc");
-        CmdArgs.push_back("-lgcc_eh");
+    if (TC.linksStaticLib(ToolChain::LT_rtlib)) {
     } else {
       if (Args.hasArg(options::OPT_shared_libgcc)) {
           CmdArgs.push_back("-lgcc_pic");
           if (!Args.hasArg(options::OPT_shared))
             CmdArgs.push_back("-lgcc");
       } else {
           CmdArgs.push_back("-lgcc");
           CmdArgs.push_back("--as-needed");

lib/Driver/ToolChains/Fuchsia.cpp

void fuchsia::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   ToolChain.addProfileRTLibs(Args, CmdArgs);
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     if (Args.hasArg(options::OPT_static))
       CmdArgs.push_back("-Bdynamic");
 
     if (D.CCCIsCXX()) {
       if (ToolChain.ShouldLinkCXXStdlib(Args)) {
-        bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
-                                   !Args.hasArg(options::OPT_static);
+        bool StaticCXXStdlib =
+            ToolChain.linksStaticLib(ToolChain::LT_cxxstdlib) &&
         CmdArgs.push_back("--push-state");
         CmdArgs.push_back("--as-needed");
-        if (OnlyLibstdcxxStatic)
+        if (StaticCXXStdlib)
           CmdArgs.push_back("-Bstatic");
         ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
-        if (OnlyLibstdcxxStatic)
+        if (StaticCXXStdlib)
           CmdArgs.push_back("-Bdynamic");
         CmdArgs.push_back("-lm");
         CmdArgs.push_back("--pop-state");
       }
     }
 
     if (NeedsSanitizerDeps)
       linkSanitizerRuntimeDeps(ToolChain, CmdArgs);

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) &&
-                                 !Args.hasArg(options::OPT_static);
-      if (OnlyLibstdcxxStatic)
+      bool StaticCXXStdlib =
+          ToolChain.linksStaticLib(ToolChain::LT_cxxstdlib) &&
+      if (StaticCXXStdlib)
         CmdArgs.push_back("-Bstatic");
       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
-      if (OnlyLibstdcxxStatic)
+      if (StaticCXXStdlib)
         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_nostdlib)) {

lib/Driver/ToolChains/Hexagon.cpp

constructHexagonLinkArgs(Compilation &C, const JobAction &JA,
 
   //----------------------------------------------------------------------------
   // Silence warnings for various options
   //----------------------------------------------------------------------------
   Args.ClaimAllArgs(options::OPT_g_Group);
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   Args.ClaimAllArgs(options::OPT_w); // Other warning options are already
                                      // handled somewhere else.
-  Args.ClaimAllArgs(options::OPT_static_libgcc);
 
   //----------------------------------------------------------------------------
   //
   //----------------------------------------------------------------------------
   if (Args.hasArg(options::OPT_s))
     CmdArgs.push_back("-s");
 
   if (Args.hasArg(options::OPT_r))

lib/Driver/ToolChains/MinGW.cpp

void tools::MinGW::Linker::AddLibGCC(const ArgList &Args,
                                      ArgStringList &CmdArgs) const {
   if (Args.hasArg(options::OPT_mthreads))
     CmdArgs.push_back("-lmingwthrd");
   CmdArgs.push_back("-lmingw32");
 
   // Make use of compiler-rt if --rtlib option is used
   ToolChain::RuntimeLibType RLT = getToolChain().GetRuntimeLibType(Args);
   if (RLT == ToolChain::RLT_Libgcc) {
-    bool Static = Args.hasArg(options::OPT_static_libgcc) ||
-                  Args.hasArg(options::OPT_static);
+    bool Static = getToolChain().linksStaticLib(ToolChain::LT_rtlib);
     bool Shared = Args.hasArg(options::OPT_shared);
     bool CXX = getToolChain().getDriver().CCCIsCXX();
 
     if (Static || (!CXX && !Shared)) {
       CmdArgs.push_back("-lgcc");
       CmdArgs.push_back("-lgcc_eh");
     } else {
       CmdArgs.push_back("-lgcc_s");
void tools::MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 
   Args.AddAllArgs(CmdArgs, options::OPT_L);
   TC.AddFilePathLibArgs(Args, CmdArgs);
   AddLinkerInputs(TC, Inputs, Args, CmdArgs, JA);
 
   // TODO: Add profile stuff here
 
   if (TC.ShouldLinkCXXStdlib(Args)) {
-    bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
-                               !Args.hasArg(options::OPT_static);
-    if (OnlyLibstdcxxStatic)
+    bool StaticCXXStdlib = TC.linksStaticLib(ToolChain::LT_cxxstdlib) &&
+    if (StaticCXXStdlib)
       CmdArgs.push_back("-Bstatic");
     TC.AddCXXStdlibLibArgs(Args, CmdArgs);
-    if (OnlyLibstdcxxStatic)
+    if (StaticCXXStdlib)
       CmdArgs.push_back("-Bdynamic");
   }
 
   bool HasWindowsApp = false;
   for (auto Lib : Args.getAllArgValues(options::OPT_l)) {
     if (Lib == "windowsapp") {
       HasWindowsApp = true;
       break;

lib/Driver/ToolChains/Myriad.cpp

void tools::Myriad::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 
   // The remaining logic is mostly like gnutools::Linker::ConstructJob,
   // but we never pass through a --sysroot option and various other bits.
   // For example, there are no sanitizers (yet) nor gold linker.
 
   // Eat some arguments that may be present but have no effect.
   Args.ClaimAllArgs(options::OPT_g_Group);
   Args.ClaimAllArgs(options::OPT_w);
-  Args.ClaimAllArgs(options::OPT_static_libgcc);
 
   if (Args.hasArg(options::OPT_s)) // Pass the 'strip' option.
     CmdArgs.push_back("-s");
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   if (UseStartfiles) {

lib/Driver/ToolChains/NaCl.cpp

if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
     CmdArgs.push_back("--no-demangle");
 
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs, JA);
 
   if (D.CCCIsCXX() &&
       !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     if (ToolChain.ShouldLinkCXXStdlib(Args)) {
       bool OnlyLibstdcxxStatic =
-          Args.hasArg(options::OPT_static_libstdcxx) && !IsStatic;
+          ToolChain.linksStaticLib(ToolChain::LT_cxxstdlib) && !IsStatic;
       if (OnlyLibstdcxxStatic)
         CmdArgs.push_back("-Bstatic");
       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
       if (OnlyLibstdcxxStatic)
         CmdArgs.push_back("-Bdynamic");
     }
     CmdArgs.push_back("-lm");
   }

test/Driver/fuchsia.cpp

 // CHECK-NOT: crtend.o
 // CHECK-NOT: crtn.o
 
 // RUN: %clangxx %s -### --target=x86_64-unknown-fuchsia -stdlib=libstdc++ \
 // RUN:     -fuse-ld=lld 2>&1 \
 // RUN:     | FileCheck %s -check-prefix=CHECK-STDLIB
 // CHECK-STDLIB: error: invalid library name in argument '-stdlib=libstdc++'
 
+// RUN: %clangxx %s -### --target=x86_64-unknown-fuchsia -static=c++stdlib \
+// RUN:     -fuse-ld=lld 2>&1 \
+// RUN:     | FileCheck %s -check-prefix=CHECK-STATIC
+
 // RUN: %clangxx %s -### --target=x86_64-unknown-fuchsia -static-libstdc++ \
 // RUN:     -fuse-ld=lld 2>&1 \
 // RUN:     | FileCheck %s -check-prefix=CHECK-STATIC
 // CHECK-STATIC: "--push-state"
 // CHECK-STATIC: "--as-needed"
 // CHECK-STATIC: "-Bstatic"
 // CHECK-STATIC: "-lc++"
 // CHECK-STATIC: "-Bdynamic"

test/Driver/linux-ld.c

 // CHECK-LD-GCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0"
 // CHECK-LD-GCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../../../x86_64-unknown-linux/lib"
 // CHECK-LD-GCC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
 // CHECK-LD-GCC: "-L[[SYSROOT]]/lib"
 // CHECK-LD-GCC: "-L[[SYSROOT]]/usr/lib"
 // CHECK-LD-GCC: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
 // CHECK-LD-GCC: "-lc"
 // CHECK-LD-GCC: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
-//
+
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform \
-// RUN:     -static-libgcc \
-// RUN:     --gcc-toolchain="" \
+// RUN:     -static=rtlib --gcc-toolchain="" \
+// RUN:     --sysroot=%S/Inputs/basic_linux_tree \
+// RUN:   | FileCheck --check-prefix=CHECK-LD-64-STATIC-LIBGCC %s
+
+// -static-libgcc is an alias of -static=rtlib
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     --target=x86_64-unknown-linux -rtlib=platform \
+// RUN:     -static-libgcc --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-LD-64-STATIC-LIBGCC %s
 // CHECK-LD-64-STATIC-LIBGCC-NOT: warning:
 // CHECK-LD-64-STATIC-LIBGCC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
 // CHECK-LD-64-STATIC-LIBGCC: "--eh-frame-hdr"
 // CHECK-LD-64-STATIC-LIBGCC: "-m" "elf_x86_64"
 // CHECK-LD-64-STATIC-LIBGCC: "-dynamic-linker"
 // CHECK-LD-64-STATIC-LIBGCC: "{{.*}}/usr/lib/gcc/x86_64-unknown-linux/4.6.0{{/|\\\\}}crtbegin.o"

 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANG-NO-LIBGCC-DYNAMIC %s
 // CHECK-CLANG-NO-LIBGCC-DYNAMIC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
 // CHECK-CLANG-NO-LIBGCC-DYNAMIC: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
 // CHECK-CLANG-NO-LIBGCC-DYNAMIC: "-lc"
 // CHECK-CLANG-NO-LIBGCC-DYNAMIC: "-lgcc" "--as-needed" "-lgcc_s" "--no-as-needed"
 //
-// RUN: %clang -static-libgcc -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN: %clang -static=rtlib -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANG-STATIC-LIBGCC %s
 // CHECK-CLANG-STATIC-LIBGCC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
 // CHECK-CLANG-STATIC-LIBGCC: "-lgcc" "-lgcc_eh"
 // CHECK-CLANG-STATIC-LIBGCC: "-lc"
 // CHECK-CLANG-STATIC-LIBGCC: "-lgcc" "-lgcc_eh"
 //
-// RUN: %clang -static-libgcc -dynamic -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN: %clang -static=rtlib -dynamic -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-CLANG-STATIC-LIBGCC-DYNAMIC %s
 // CHECK-CLANG-STATIC-LIBGCC-DYNAMIC: "{{.*}}ld{{(.exe)?}}" "--sysroot=[[SYSROOT:[^"]+]]"
 // CHECK-CLANG-STATIC-LIBGCC-DYNAMIC: "-lgcc" "-lgcc_eh"
 // CHECK-CLANG-STATIC-LIBGCC-DYNAMIC: "-lc"
 // CHECK-CLANG-STATIC-LIBGCC-DYNAMIC: "-lgcc" "-lgcc_eh"

 // CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib/gcc/x86_64-unknown-linux/4.6.0/../../.."
 // CHECK-LD-64-STATIC: "-L[[SYSROOT]]/lib"
 // CHECK-LD-64-STATIC: "-L[[SYSROOT]]/usr/lib"
 // CHECK-LD-64-STATIC: "--start-group" "-lgcc" "-lgcc_eh" "-lc" "--end-group"
 //
 // Check that flags can be combined. The -static dominates.
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=x86_64-unknown-linux -rtlib=platform \
-// RUN:     -static-libgcc -static \
+// RUN:     -static=rtlib -static \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-LD-64-STATIC %s
 //
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
 // RUN:     --target=i386-unknown-linux -rtlib=platform -m32 \
 // RUN:     --gcc-toolchain="" \
 // RUN:     --sysroot=%S/Inputs/multilib_32bit_linux_tree \

test/Driver/linux-musl.cpp

+// RUN: %clangxx -no-canonical-prefixes %s -### -target x86_64-linux-musl 2>&1 \
+// RUN:   -static=c++stdlib -stdlib=libc++ \
+// RUN:   -ccc-install-dir %S/Inputs/basic_linux_tree/usr/bin \
+// RUN:   --sysroot=%S/Inputs/basic_linux_libcxx_tree \
+// RUN:   | FileCheck --check-prefix=CHECK-STATIC-LIBCXX %s
+// CHECK-STATIC-LIBCXX: "-Bstatic" "-lc++" "-Bdynamic" "-lm" "-lgcc_s" "-lgcc" "-lc" "-lgcc_s" "-lgcc"
+
+// RUN: %clangxx -no-canonical-prefixes %s -### -target x86_64-linux-musl 2>&1 \
+// RUN:   -static=c++stdlib,rtlib -stdlib=libc++ \
+// RUN:   -ccc-install-dir %S/Inputs/basic_linux_tree/usr/bin \
+// RUN:   --sysroot=%S/Inputs/basic_linux_libcxx_tree \
+// RUN:   | FileCheck --check-prefix=CHECK-STATIC-LIBCXX-RTLIB %s
+// CHECK-STATIC-LIBCXX-RTLIB: "-Bstatic" "-lc++" "-Bdynamic" "-lm" "-lgcc" "-lgcc_eh" "-lc" "-lgcc" "-lgcc_eh"

test/Driver/static.c

+// RUN: %clang -target %itanium_abi_triple %s -static=c++stdlib,rtlib -### 2>&1 | \
+// RUN:   FileCheck /dev/null --implicit-check-not=error:
+
+// RUN: %clang -target %itanium_abi_triple %s -static=unknown -### 2>&1 | FileCheck --check-prefix=STATIC-UNKNOWN %s
+// STATIC-UNKNOWN: error: unsupported argument 'unknown' to option 'static='