Add --unwindlib=[libgcc|compiler-rt] to parallel --rtlib= [take 2]

[saugustine]

Summary

"clang++ hello.cc --rtlib=compiler-rt"

now can works without specifying additional unwind or exception
handling libraries.

This reworked version of the feature no longer modifies today's default
unwind library for compiler-rt: which is nothing. Rather, a user
can specify -DCLANG_DEFAULT_UNWINDLIB=compiler-rt when configuring
the compiler.

This should address the issues from the previous version.

Update tests for new --unwindlib semantics.

[phosek]

clang/include/clang/Driver/ToolChain.h

104

I think it's confusing to call LLVM's libunwind library compiler-rt since they're two separate and distinct LLVM subprojects. Is there a plan to move LLVM's libunwind into compiler-rt?

[mgorny]

clang/include/clang/Driver/ToolChain.h

104

Also, note that -lunwind may actually be 'non-GNU libunwind'. Both libraries normally use the same name.

[MaskRay]

clang/include/clang/Driver/ToolChain.h

104

Yeah there are lots of projects called "libunwind":

llvm libunwind
nongnu libunwind https://www.nongnu.org/libunwind/
PathScale libunwind https://github.com/pathscale/libunwind (this is used by default On FreeBSD)
(libgcc_s.so.1 doesn't call itself "libunwind")

[phosek]

clang/include/clang/Driver/ToolChain.h

104

There have been suggestions to rename LLVM's libunwind to avoid this confusion in the past, maybe it's time to do it?

[saugustine]

clang/include/clang/Driver/ToolChain.h

104

The issues with the name "libunwind" come up pretty much constantly, and various people have proposed renaming llvm's libunwind (as someone did when commenting on v1 of this patch), but it never really goes anywhere. Others have suggested rolling it into compiler-rt, which makes quite a bit of sense to me, but is not really something I can do.

libgcc_s.so.1 doesn't call itself libunwind, but it provides the unwind symbols. As does libgcc_eh.

If you bootstrap clang with -DLLVM_ENABLE_PROJECTS="...,libunwind", then clang tries to use llvm's libunwind in its testing if -lunwind appears on the link line. It isn't built in enough variants to even run the test suite. For example, it would be missing a normal x86 abi build. Compare that to compiler-rt, which builds a copy for every variant.

So solving libunwind's name problem is out of scope for this patch.

Perhaps the best thing to do here is to make the option an actual driver argument string, rather than name an. --unwindlib="-lunwind" or "-lgcc_s".

[saugustine]

clang/include/clang/Driver/ToolChain.h

104

There are various plans, see, for example, https://reviews.llvm.org/D57128.

But the current plan is to wait until after things solidify on github, and I would prefer not to wait on this patch.

And I can't handle this as a string, because the libgcc unwind library changes depending on whether the link is static and so on.

So I think this patch as written is the best option, unless just adding "libunwind" instead of compiler-rt is people's choice. But which libunwind gets found is highly system dependent.

[saugustine]

rsmith: Do you have any comments on the naming here?

"--unwindlib=compiler-rt" has the disadvantage that the llvm-unwind lib isn't inside compiler-rt (although there are hints of moving it there).

Using --unwindlib="some-string-passed-exactly-as-is-to-the-linker" cannot work because we should use "-lgcc_s" for some links and "-lgcc_eh" for others.

-lunwind has the disadvantage of picking up whatever libunwind happens to be first in the search path. Fixing that would require moving llvm-libunwind into compiler-rt and naming it differently.

[mgorny]

In D59109#1427659, @saugustine wrote:

-lunwind has the disadvantage of picking up whatever libunwind happens to be first in the search path. Fixing that would require moving llvm-libunwind into compiler-rt and naming it differently.

Is this really a problem? Don't forget the dynamic loader is going to use the first library in the search path as well.

[saugustine]

This comment was removed by saugustine.

[saugustine]

• Undo cpu model change.

[saugustine]

• Add --unwindlib=[libgcc|compiler-rt] to parallel --rtlib= [take 2]
• Change option argument --unwindlib= from "compiler-rt" to "libunwind".
• Fix tests syntax and driver checks for --unwindlib=

[saugustine]

I have now switched it to use --unwindlib=[libgcc|libunwind]

If there are no objections to this going in, I'm going to submit tomorrow morning.

phosek:
kristina:
mstorsjo:
uabelho:

I'm hoping for your review because the last version of this change broke your builds. Any comments?

[MaskRay]

clang/lib/Driver/ToolChain.cpp

695

Is it return ToolChain::UNW_CompilerRT;?

[MaskRay]

clang/lib/Driver/ToolChain.cpp

695

Sorry I didn't read the previous discussion :)

702

} else if

[saugustine]

clang/lib/Driver/ToolChain.cpp

695

Just so that no one else needs to go back and read the previous discussion:

Current users of --rtlib=compiler-rt use a wide variety of platform specific methods of getting their libunwind symbols, and anything else breaks their build.

So the default when --rtlib=compiler-rt is no unwind library at all.

[phosek]

This broke our builders, the error is the following:

FAIL: Clang :: Driver/compiler-rt-unwind.c (4674 of 14362)
******************** TEST 'Clang :: Driver/compiler-rt-unwind.c' FAILED ********************
Script:
--
: 'RUN: at line 4';   /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/clang -no-canonical-prefixes /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c -### -o /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.o 2>&1      --target=x86_64-unknown-linux      --gcc-toolchain=""    | /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/FileCheck --check-prefix=RTLIB-EMPTY /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c
: 'RUN: at line 11';   /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/clang -no-canonical-prefixes /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c -### -o /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.o 2>&1      --target=x86_64-unknown-linux -rtlib=libgcc      --gcc-toolchain=""    | /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/FileCheck --check-prefix=RTLIB-GCC /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c
: 'RUN: at line 18';   /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/clang -no-canonical-prefixes /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c -### -o /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.o 2>&1      --target=x86_64-unknown-linux -rtlib=libgcc --unwindlib=libunwind      --gcc-toolchain=""    | /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/FileCheck --check-prefix=RTLIB-GCC-UNWINDLIB-COMPILER-RT /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c
: 'RUN: at line 25';   /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/clang -no-canonical-prefixes /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c -### -o /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.o 2>&1        --target=x86_64-unknown-linux -rtlib=compiler-rt      --gcc-toolchain=""    | /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/FileCheck --check-prefix=RTLIB-COMPILER-RT /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c
: 'RUN: at line 31';   /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/clang -no-canonical-prefixes /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c -### -o /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.o 2>&1        --target=x86_64-unknown-linux -rtlib=compiler-rt --unwindlib=libgcc      --gcc-toolchain=""    | /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/FileCheck --check-prefix=RTLIB-COMPILER-RT-UNWINDLIB-GCC /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c
: 'RUN: at line 38';   /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/clang -no-canonical-prefixes /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c -### -o /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.o 2>&1                   --target=x86_64-unknown-linux -rtlib=compiler-rt --unwindlib=libgcc      -static --gcc-toolchain=""    | /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/FileCheck --check-prefix=RTLIB-COMPILER-RT-UNWINDLIB-GCC-STATIC /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c
: 'RUN: at line 45';   not /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/clang -no-canonical-prefixes /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c -o /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.o 2> /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.err                   --target=x86_64-unknown-linux -rtlib=libgcc --unwindlib=libunwind      --gcc-toolchain=""  /b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/FileCheck --input-file=/b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver/Output/compiler-rt-unwind.c.tmp.err --check-prefix=RTLIB-GCC-UNWINDLIB-COMPILER_RT /b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c
--
Exit Code: 1

Command Output (stderr):
--
/b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c:8:17: error: RTLIB-EMPTY: expected string not found in input
// RTLIB-EMPTY: "{{.*}}lgcc"
                ^
<stdin>:1:1: note: scanning from here
Fuchsia clang version 9.0.0 (https://fuchsia.googlesource.com/a/third_party/llvm-project ba92e9bb1187a2c43ab727fb9685b65898a87a9d) (based on LLVM 9.0.0svn)
^
<stdin>:5:979: note: possible intended match here
 "/b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/bin/clang" "-cc1" "-triple" "x86_64-unknown-linux" "-emit-obj" "-mrelax-all" "--mrelax-relocations" "-disable-free" "-main-file-name" "compiler-rt-unwind.c" "-mrelocation-model" "static" "-mthread-model" "posix" "-mdisable-fp-elim" "-fmath-errno" "-masm-verbose" "-mconstructor-aliases" "-munwind-tables" "-fuse-init-array" "-target-cpu" "x86-64" "-dwarf-column-info" "-debugger-tuning=gdb" "-resource-dir" "/b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/lib/clang/9.0.0" "-internal-isystem" "/usr/local/include" "-internal-isystem" "/b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/lib/clang/9.0.0/include" "-internal-externc-isystem" "/usr/include/x86_64-linux-gnu" "-internal-externc-isystem" "/include" "-internal-externc-isystem" "/usr/include" "-fdebug-compilation-dir" "/b/s/w/ir/k/recipe_cleanup/clangcmtTrW/llvm_build_dir/tools/clang/test/Driver" "-ferror-limit" "19" "-fmessage-length" "0" "-fobjc-runtime=gcc" "-fdiagnostics-show-option" "-o" "/b/s/w/ir/tmp/t/lit_tmp_A2OKVE/compiler-rt-unwind-347fd6.o" "-x" "c" "/b/s/w/ir/k/llvm-project/clang/test/Driver/compiler-rt-unwind.c" "-faddrsig"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ^

--

The full log is here: https://luci-milo.appspot.com/p/fuchsia/builders/ci/clang-x64-linux/b8918524447769519952

[phosek]

We set compiler-rt as the default runtime library in our toolchain (through CLANG_DEFAULT_RTLIB), so this check is invalid:

// RTLIB-EMPTY: "{{.*}}lgcc"
// RTLIB-EMPTY: "{{.*}}-lgcc_s"

[phosek]

Is it possible to either fix the test or revert this change? Our builders have been failing for second day. I would have sent a patch but I'm out-of-office until next week.

clang/CMakeLists.txt

 if (NOT(CLANG_DEFAULT_RTLIB STREQUAL "" OR
         CLANG_DEFAULT_RTLIB STREQUAL "libgcc" OR
         CLANG_DEFAULT_RTLIB STREQUAL "compiler-rt"))
   message(WARNING "Resetting default rtlib to use platform default")
   set(CLANG_DEFAULT_RTLIB "" CACHE STRING
     "Default runtime library to use (\"libgcc\" or \"compiler-rt\", empty for platform default)" FORCE)
 endif()
 
+set(CLANG_DEFAULT_UNWINDLIB "" CACHE STRING
+  "Default unwind library to use (\"none\" \"libgcc\" or \"compiler-rt\", empty to match runtime library.)")
+if (CLANG_DEFAULT_UNWINDLIB STREQUAL "")
+  if (CLANG_DEFAULT_RTLIB STREQUAL "libgcc")
+    set (CLANG_DEFAULT_UNWINDLIB "libgcc" CACHE STRING "" FORCE)
+  elseif (CLANG_DEFAULT_RTLIBS STREQUAL "compiler-rt")
+    set (CLANG_DEFAULT_UNWINDLIB "none" CACHE STRING "" FORCE)
+  endif()
+endif()
+
+if (NOT(CLANG_DEFAULT_UNWINDLIB STREQUAL "none" OR
+        CLANG_DEFAULT_UNWINDLIB STREQUAL "libgcc" OR
+        CLANG_DEFAULT_UNWINDLIB STREQUAL "compiler-rt"))
+  message(WARNING "Resetting default unwindlib to use platform default")
+  set(CLANG_DEFAULT_UNWINDLIB "" CACHE STRING
+    "Default unwind library to use (\"none\" \"libgcc\" or \"compiler-rt\", empty for none)" FORCE)
+endif()
+
 set(CLANG_DEFAULT_OBJCOPY "objcopy" CACHE STRING
   "Default objcopy executable to use.")
 
 set(CLANG_DEFAULT_OPENMP_RUNTIME "libomp" CACHE STRING
   "Default OpenMP runtime used by -fopenmp.")
 
 # OpenMP offloading requires at least sm_35 because we use shuffle instructions
 # to generate efficient code for reductions and the atomicMax instruction on

clang/include/clang/Basic/DiagnosticDriverKinds.td

 def err_drv_invalid_linker_name : Error<
   "invalid linker name in argument '%0'">;
 def err_drv_invalid_pgo_instrumentor : Error<
   "invalid PGO instrumentor in argument '%0'">;
 def err_drv_invalid_rtlib_name : Error<
   "invalid runtime library name in argument '%0'">;
 def err_drv_unsupported_rtlib_for_platform : Error<
   "unsupported runtime library '%0' for platform '%1'">;
+def err_drv_invalid_unwindlib_name : Error<
+  "invalid unwind library name in argument '%0'">;
+def err_drv_incompatible_unwindlib : Error<
+  "--rtlib=libgcc requires --unwindlib=libgcc">;
 def err_drv_invalid_stdlib_name : Error<
   "invalid library name in argument '%0'">;
 def err_drv_invalid_output_with_multiple_archs : Error<
   "cannot use '%0' output with multiple -arch options">;
 def err_drv_no_input_files : Error<"no input files">;
 def err_drv_use_of_Z_option : Error<
   "unsupported use of internal gcc -Z option '%0'">;
 def err_drv_output_argument_with_multiple_files : Error<

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

 #cmakedefine CLANG_DEFAULT_STD_CXX LangStandard::lang_${CLANG_DEFAULT_STD_CXX}
 
 /* Default C++ stdlib to use. */
 #define CLANG_DEFAULT_CXX_STDLIB "${CLANG_DEFAULT_CXX_STDLIB}"
 
 /* Default runtime library to use. */
 #define CLANG_DEFAULT_RTLIB "${CLANG_DEFAULT_RTLIB}"
 
+/* Default unwind library to use. */
+#define CLANG_DEFAULT_UNWINDLIB "${CLANG_DEFAULT_UNWINDLIB}"
+
 /* Default objcopy to use */
 #define CLANG_DEFAULT_OBJCOPY "${CLANG_DEFAULT_OBJCOPY}"
 
 /* Default OpenMP runtime used by -fopenmp. */
 #define CLANG_DEFAULT_OPENMP_RUNTIME "${CLANG_DEFAULT_OPENMP_RUNTIME}"
 
 /* Default architecture for OpenMP offloading to Nvidia GPUs. */
 #define CLANG_OPENMP_NVPTX_DEFAULT_ARCH "${CLANG_OPENMP_NVPTX_DEFAULT_ARCH}"

clang/include/clang/Driver/Options.td

ValuesCode<[{
     const char *Values =
     #define LANGSTANDARD(id, name, lang, desc, features) name ","
     #define LANGSTANDARD_ALIAS(id, alias) alias ","
     #include "clang/Frontend/LangStandards.def"
     ;
   }]>;
 def stdlib_EQ : Joined<["-", "--"], "stdlib=">, Flags<[CC1Option]>,
   HelpText<"C++ standard library to use">, Values<"libc++,libstdc++,platform">;
+def unwindlib_EQ : Joined<["-", "--"], "unwindlib=">, Flags<[CC1Option]>,
+  HelpText<"Unwind library to use">, Values<"libgcc,compiler-rt,platform">;
 def sub__library : JoinedOrSeparate<["-"], "sub_library">;
 def sub__umbrella : JoinedOrSeparate<["-"], "sub_umbrella">;
 def system_header_prefix : Joined<["--"], "system-header-prefix=">,
   Group<clang_i_Group>, Flags<[CC1Option]>, MetaVarName<"<prefix>">,
   HelpText<"Treat all #include paths starting with <prefix> as including a "
            "system header.">;
 def : Separate<["--"], "system-header-prefix">, Alias<system_header_prefix>;
 def no_system_header_prefix : Joined<["--"], "no-system-header-prefix=">,

clang/include/clang/Driver/ToolChain.h

enum CXXStdlibType {
     CST_Libstdcxx
   };
 
   enum RuntimeLibType {
     RLT_CompilerRT,
     RLT_Libgcc
   };
 
+  enum UnwindLibType {
+    UNW_None,
+    UNW_CompilerRT,
+    UNW_Libgcc
+  };
+
   enum RTTIMode {
     RM_Enabled,
     RM_Disabled,
   };
 
 private:
   friend class RegisterEffectiveTriple;
 
public:
   virtual RuntimeLibType GetDefaultRuntimeLibType() const {
     return ToolChain::RLT_Libgcc;
   }
 
   virtual CXXStdlibType GetDefaultCXXStdlibType() const {
     return ToolChain::CST_Libstdcxx;
   }
 
+  virtual UnwindLibType GetDefaultUnwindLibType() const {
+    return ToolChain::UNW_None;
+  }
+
   virtual std::string getCompilerRTPath() const;
 
   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,
public:
   // given compilation arguments.
   virtual RuntimeLibType
   GetRuntimeLibType(const llvm::opt::ArgList &Args) const;
 
   // GetCXXStdlibType - Determine the C++ standard library type to use with the
   // given compilation arguments.
   virtual CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const;
 
+  // GetUnwindLibType - Determine the unwind library type to use with the
+  // given compilation arguments.
+  virtual UnwindLibType GetUnwindLibType(const llvm::opt::ArgList &Args) const;
+
   /// AddClangCXXStdlibIncludeArgs - Add the clang -cc1 level arguments to set
   /// the include paths to use for the given C++ standard library type.
   virtual void
   AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                                llvm::opt::ArgStringList &CC1Args) const;
 
   /// Returns if the C++ standard library should be linked in.
   /// Note that e.g. -lm should still be linked even if this returns false.

clang/lib/Driver/ToolChain.cpp

else if (LibName == "platform")
     return GetDefaultRuntimeLibType();
 
   if (A)
     getDriver().Diag(diag::err_drv_invalid_rtlib_name) << A->getAsString(Args);
 
   return GetDefaultRuntimeLibType();
 }
 
+ToolChain::UnwindLibType ToolChain::GetUnwindLibType(
+    const ArgList &Args) const {
+  const Arg *A = Args.getLastArg(options::OPT_unwindlib_EQ);
+  StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_UNWINDLIB;
+
+  if (LibName == "none")
+    return ToolChain::UNW_None;
+  else if (LibName == "platform" || LibName == "") {
+    ToolChain::RuntimeLibType RtLibType = GetRuntimeLibType(Args);
+    if (RtLibType == ToolChain::RLT_CompilerRT)
+      return ToolChain::UNW_None;
+    else if (RtLibType == ToolChain::RLT_Libgcc)
+      return ToolChain::UNW_Libgcc;
+  } else if (LibName == "compiler-rt") {
+    if (GetRuntimeLibType(Args) == RLT_Libgcc)
+      getDriver().Diag(diag::err_drv_incompatible_unwindlib);
+    return ToolChain::UNW_CompilerRT;
+  }
+  else if (LibName == "libgcc")
+    return ToolChain::UNW_Libgcc;
+
+  if (A)
+    getDriver().Diag(diag::err_drv_invalid_unwindlib_name)
+        << A->getAsString(Args);
+
+  return GetDefaultUnwindLibType();
+}
+
 ToolChain::CXXStdlibType ToolChain::GetCXXStdlibType(const ArgList &Args) const{
   const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ);
   StringRef LibName = A ? A->getValue() : CLANG_DEFAULT_CXX_STDLIB;
 
   // Only use "platform" in tests to override CLANG_DEFAULT_CXX_STDLIB!
   if (LibName == "libc++")
     return ToolChain::CST_Libcxx;
   else if (LibName == "libstdc++")

clang/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);
 }
 
-static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
-                      ArgStringList &CmdArgs, const ArgList &Args) {
-  bool isAndroid = Triple.isAndroid();
-  bool isCygMing = Triple.isOSCygMing();
-  bool IsIAMCU = Triple.isOSIAMCU();
-  bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
-                      Args.hasArg(options::OPT_static) ||
-                      Args.hasArg(options::OPT_static_pie);
+enum class LibGccType { UnspecifiedLibGcc, StaticLibGcc, SharedLibGcc };
+
+static LibGccType getLibGccType(const ArgList &Args) {
+  bool Static = Args.hasArg(options::OPT_static_libgcc) ||
 
-  bool SharedLibgcc = Args.hasArg(options::OPT_shared_libgcc);
-  bool UnspecifiedLibgcc = !StaticLibgcc && !SharedLibgcc;
+  bool Shared = Args.hasArg(options::OPT_shared_libgcc);
+  if (Shared)
+    return LibGccType::SharedLibGcc;
+  if (Static)
+    return LibGccType::StaticLibGcc;
+  return LibGccType::UnspecifiedLibGcc;
+}
 
-  // Gcc adds libgcc arguments in various ways:
-  //
-  // gcc <none>:     -lgcc --as-needed -lgcc_s --no-as-needed
-  // g++ <none>:                       -lgcc_s               -lgcc
-  // gcc shared:                       -lgcc_s               -lgcc
-  // g++ shared:                       -lgcc_s               -lgcc
-  // gcc static:     -lgcc             -lgcc_eh
-  // g++ static:     -lgcc             -lgcc_eh
-  // gcc static-pie: -lgcc             -lgcc_eh
-  // g++ static-pie: -lgcc             -lgcc_eh
-  //
-  // Also, certain targets need additional adjustments.
 
-  bool LibGccFirst = (D.CCCIsCC() && UnspecifiedLibgcc) || StaticLibgcc;
-  if (LibGccFirst)
-    CmdArgs.push_back("-lgcc");
+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;
 
-  bool AsNeeded = D.CCCIsCC() && UnspecifiedLibgcc && !isAndroid && !isCygMing;
+  LibGccType LGT = getLibGccType(Args);
+  bool AsNeeded = D.CCCIsCC() && LGT == LibGccType::UnspecifiedLibGcc &&
+                  !TC.getTriple().isAndroid() && !TC.getTriple().isOSCygMing();
   if (AsNeeded)
     CmdArgs.push_back("--as-needed");
 
-  if ((UnspecifiedLibgcc || SharedLibgcc) && !isAndroid)
+  switch (UNW) {
+  case ToolChain::UNW_None:
+    return;
+  case ToolChain::UNW_Libgcc: {
+    LibGccType LGT = getLibGccType(Args);
+    if (LGT == LibGccType::UnspecifiedLibGcc || LGT == LibGccType::SharedLibGcc)
       CmdArgs.push_back("-lgcc_s");
-
-  else if (StaticLibgcc && !isAndroid && !IsIAMCU)
+    else if (LGT == LibGccType::StaticLibGcc)
       CmdArgs.push_back("-lgcc_eh");
+    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) {
+  bool isAndroid = TC.getTriple().isAndroid();
+
+  LibGccType LGT = getLibGccType(Args);
+  bool LibGccFirst = (D.CCCIsCC() && LGT == LibGccType::UnspecifiedLibGcc) ||
+                     LGT == LibGccType::StaticLibGcc;
+  if (LibGccFirst)
+    CmdArgs.push_back("-lgcc");
+
+  AddUnwindLibrary(TC, D, CmdArgs, Args);
 
   if (!LibGccFirst)
     CmdArgs.push_back("-lgcc");
 
   // According to Android ABI, we have to link with libdl if we are
   // linking with non-static libgcc.
   //
   // NOTE: This fixes a link error on Android MIPS as well.  The non-static
   // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl.
-  if (isAndroid && !StaticLibgcc)
+  if (isAndroid && getLibGccType(Args) != LibGccType::StaticLibGcc)
     CmdArgs.push_back("-ldl");
 }
 
 void tools::AddRunTimeLibs(const ToolChain &TC, const Driver &D,
                            ArgStringList &CmdArgs, const ArgList &Args) {
   // Make use of compiler-rt if --rtlib option is used
   ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
 
   switch (RLT) {
   case ToolChain::RLT_CompilerRT:
     CmdArgs.push_back(TC.getCompilerRTArgString(Args, "builtins"));
+    AddUnwindLibrary(TC, D, CmdArgs, Args);
     break;
   case ToolChain::RLT_Libgcc:
     // Make sure libgcc is not used under MSVC environment by default
     if (TC.getTriple().isKnownWindowsMSVCEnvironment()) {
       // Issue error diagnostic if libgcc is explicitly specified
       // through command line as --rtlib option argument.
       if (Args.hasArg(options::OPT_rtlib_EQ)) {
         TC.getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform)
             << Args.getLastArg(options::OPT_rtlib_EQ)->getValue() << "MSVC";
       }
     } else
-      AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
+      AddLibgcc(TC, D, CmdArgs, Args);
     break;
   }
 }
 
 /// Add OpenMP linker script arguments at the end of the argument list so that
 /// the fat binary is built by embedding each of the device images into the
 /// host. The linker script also defines a few symbols required by the code
 /// generation so that the images can be easily retrieved at runtime by the

clang/test/Driver/compiler-rt-unwind.c

+// General tests that the driver handles combinations of --rtlib=XXX and
+// --unwindlib=XXX properly.
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     --target=x86_64-unknown-linux \
+// RUN:     --gcc-toolchain="" \
+// RUN:   | FileCheck --check-prefix=RTLIB-EMPTY %s
+// RTLIB-EMPTY: "{{.*}}lgcc"
+// RTLIB-EMPTY: "{{.*}}-lgcc_s"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     --target=x86_64-unknown-linux -rtlib=gcc \
+// RUN:     --gcc-toolchain="" \
+// RUN:   | FileCheck --check-prefix=RTLIB-GCC %s
+// RTLIB-GCC: "{{.*}}lgcc"
+// RTLIB-GCC: "{{.*}}lgcc_s"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1 \
+// RUN:     --target=x86_64-unknown-linux -rtlib=gcc --unwindlib=compiler-rt \
+// RUN:     --gcc-toolchain="" \
+// RUN:   | FileCheck --check-prefix=RTLIB-GCC-UNWINDLIB-COMPILER-RT %s
+// RTLIB-GCC-UNWINDLIB-COMPILER-RT: "{{.*}}lgcc"
+// RTLIB-GCC-UNWINDLIB-COMPILER-RT: "{{.*}}lunwind"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1   \
+// RUN:     --target=x86_64-unknown-linux -rtlib=compiler-rt \
+// RUN:     --gcc-toolchain="" \
+// RUN:   | FileCheck --check-prefix=RTLIB-COMPILER-RT %s
+// RTLIB-COMPILER-RT: "{{.*}}libclang_rt.builtins-x86_64.a"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1   \
+// RUN:     --target=x86_64-unknown-linux -rtlib=compiler-rt --unwindlib=gcc \
+// RUN:     --gcc-toolchain="" \
+// RUN:   | FileCheck --check-prefix=RTLIB-COMPILER-RT-UNWINDLIB-GCC %s
+// RTLIB-COMPILER-RT-UNWINDLIB-GCC: "{{.*}}libclang_rt.builtins-x86_64.a"
+// RTLIB-COMPILER-RT-UNWINDLIB-GCC: "{{.*}}lgcc_s"
+//
+// RUN: %clang -no-canonical-prefixes %s -### -o %t.o 2>&1              \
+// RUN:     --target=x86_64-unknown-linux -rtlib=compiler-rt --unwindlib=gcc \
+// RUN:     -static --gcc-toolchain="" \
+// RUN:   | FileCheck --check-prefix=RTLIB-COMPILER-RT-UNWINDLIB-GCC-STATIC %s
+// RTLIB-COMPILER-RT-UNWINDLIB-GCC-STATIC: "{{.*}}libclang_rt.builtins-x86_64.a"
+// RTLIB-COMPILER-RT-UNWINDLIB-GCC-STATIC: "{{.*}}lgcc_eh"
+//
+// RUN: not %clang -no-canonical-prefixes %s -o %t.o 2> %t.err              \
+// RUN:     --target=x86_64-unknown-linux -rtlib=libgcc --unwindlib=compiler-rt \
+// RUN:     --gcc-toolchain="" \
+// RUN: FileCheck --input-file=%t.err --check-prefix=RTLIB-GCC-UNWINDLIB-COMPILER_RT %s
+// RTLIB-GCC-UNWINDLIB-COMPILER_RT: "{{[.|\\\n]*}}--rtlib=libgcc requires --unwindlib=libgcc"