Add support for -rtlib option and -stdlib option to the mingw driver

[martell]

Summary

Hi,

this is the last of the 5 patches from

http://reviews.llvm.org/D11077

I have left the defaults as libgcc and libstdc++ so that this can hit the 3.7 branch :)
This is a fix for 2 options that should be supported in the driver.

[martell]

Set libgcc and libstdc++ as default so this can be considered as a fix for the 3.7 branch :)

[rnk]

tools/clang/lib/Driver/MinGWToolChain.cpp

206 ↗

(On Diff #29821)

You don't need to override this, you can simply override GetDefaultRuntimeLibType() and leave the base class behavior for this.

tools/clang/lib/Driver/ToolChains.h

546–552 ↗

(On Diff #29821)

So far as I can tell, none of these overrides have any functionality change other than creating a place for TODOs. I'd rather just wait until we're ready to change the behavior, and then we can see how to do it with the least duplication.

tools/clang/lib/Driver/Tools.cpp

9064 ↗

(On Diff #29821)

Can't this just be AddRunTimeLibs() and then it won't require changing AddLibGCC?

9085 ↗

(On Diff #29821)

ditto

[martell]

Updated to address rnk's suggested changes

[martell]

ping :)

tools/clang/lib/Driver/MinGWToolChain.cpp

158 ↗

(On Diff #29821)

Not quite sure if using "v1" here is okay ?

206 ↗

(On Diff #29821)

Ahh I see that function now.
This makes it easier :)

I don't see a GetDefaultCXXStdlibType maybe that is something that should be added after 3.7

tools/clang/lib/Driver/ToolChains.h

546–552 ↗

(On Diff #29821)

I actually have the behavior changed in my builds, this makes it easier to change but your point makes perfect sense.
I can remove this part of the patch :)

tools/clang/lib/Driver/Tools.cpp

9064 ↗

(On Diff #29821)

static void AddLibgcc(const llvm::Triple &Triple, const Driver &D, ArgStringList &CmdArgs, const ArgList &Args)

and

void MinGW::Linker::AddLibGCC(const ArgList &Args, ArgStringList &CmdArgs)

Are completely separate function and one is not belong to a class hierarchy so this isn't possible I don't think

The name change was done to clarify what exactly it was

[yaron.keren]

I just added support for Arch Linux to MinGWToolChain.cpp. It appears that all permutations of {"usr" "lib" "lib64" "gcc" gcc-ver Arch } for the mingw include and lib directories actually exist on the various platforms.

Anyhow please rebase the patch to the current SVN.

[martell]

Updated to latest SVN as requested by Yaron

[rnk]

tools/clang/lib/Driver/Tools.cpp

9087 ↗

(On Diff #30156)

You still don't need this, see the static helper AddRunTimeLibs() in Tools.cpp. It already has all this logic, and shares it across tools. We should make the mingw linker tool use it, just like the gnutools linker does.

[martell]

I hope this is what you meant rnk :)

[martell]

Added a comment regarding libunwind

tools/clang/lib/Driver/Tools.cpp

2307 ↗

(On Diff #30221)

Still not sure what way is the best location for installing libunwind is

lib/clang/3.8.0/lib/windows/libclang_rt.unwind-x86_64.a
lib/clang/3.8.0/lib/windows/libclang_rt.unwind-x86.a
etc
via
CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "unwind")));
or

lib/libunwind.a
via
CmdArgs.push_back("-lunwind");

Thoughts?

[martell]

Changed the default to libgcc_eh so that we can get this merged.

We can deal with using a libunwind later.
Only a few days left to get this approved and merged in

[martell]

Updated to latest svn.

After some hard testing on windows I discovered we do not need to pass the exception library when using libc++.dll because it is a shared library.

That is the reason why the code already contains
if (!TC.getTriple().isOSWindows())

since we don't handle a OPT_static_libgcc equivalent for compiler-rt
it makes more sense to leave this code alone

Please Review

Many Thanks
Martell

[rnk]

In D11237#208710, @martell wrote:

I hope this is what you meant rnk :)

I see, your change was better as it was. I put back AddLibGCC and I'm going to commit it like that. Please test it and let me know if it still works, and then we can try to merge to 3.7.

[rnk]

tools/clang/lib/Driver/Tools.cpp

7845 ↗

(On Diff #30322)

I had to change this to Triple.isOSCygMing() to make the existing windows-cross toolchain driver test pass. It expected --as-needed to be passed along.

[martell]

This comment was removed by martell.

tools/clang/lib/Driver/Tools.cpp

5 ↗

(On Diff #30322)

This if specifically breaks mingw-w64

That's why I changed it to

TC.getTriple().isWindowsMSVCEnvironment()

13 ↗

(On Diff #30322)

You sure you didn't revert all this by accident ?

the lib extension is now broken on mingw-w64 also ???

15 ↗

(On Diff #30322)

ditto

[martell]

Yup looks good to me.
Please ignore previous comment.
I dunno what phabricator is doing :)

cfe/trunk/lib/Driver/MinGWToolChain.cpp

if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
     SmallString<1024> P(getDriver().ResourceDir);
     llvm::sys::path::append(P, "include");
     addSystemInclude(DriverArgs, CC1Args, P.str());
   }
 
   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
     return;
 
+  if (GetRuntimeLibType(DriverArgs) == ToolChain::RLT_Libgcc) {
     llvm::SmallString<1024> IncludeDir(GccLibDir);
     llvm::sys::path::append(IncludeDir, "include");
     addSystemInclude(DriverArgs, CC1Args, IncludeDir.c_str());
     IncludeDir += "-fixed";
 #ifdef LLVM_ON_UNIX
     // openSUSE
     addSystemInclude(DriverArgs, CC1Args,
                      "/usr/x86_64-w64-mingw32/sys-root/mingw/include");
 #endif
     addSystemInclude(DriverArgs, CC1Args, IncludeDir.c_str());
+  }
   addSystemInclude(DriverArgs, CC1Args, Base + Arch + "include");
   addSystemInclude(DriverArgs, CC1Args, Base + "include");
 }
 
 void MinGW::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
                                          ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
       DriverArgs.hasArg(options::OPT_nostdincxx))
     return;
 
+  switch (GetCXXStdlibType(DriverArgs)) {
+  case ToolChain::CST_Libcxx:
+    addSystemInclude(DriverArgs, CC1Args, Base        + "include" +
+                     llvm::sys::path::get_separator() + "c++"     +
+                     llvm::sys::path::get_separator() + "v1");
+    break;
+
+  case ToolChain::CST_Libstdcxx:
     llvm::SmallVector<llvm::SmallString<1024>, 4> CppIncludeBases;
     CppIncludeBases.emplace_back(Base);
     llvm::sys::path::append(CppIncludeBases[0], Arch, "include", "c++");
     CppIncludeBases.emplace_back(Base);
     llvm::sys::path::append(CppIncludeBases[1], Arch, "include", "c++", Ver);
     CppIncludeBases.emplace_back(Base);
     llvm::sys::path::append(CppIncludeBases[2], "include", "c++", Ver);
     CppIncludeBases.emplace_back(GccLibDir);
     llvm::sys::path::append(CppIncludeBases[3], "include", "c++");
     for (auto &CppIncludeBase : CppIncludeBases) {
       CppIncludeBase += llvm::sys::path::get_separator();
       addSystemInclude(DriverArgs, CC1Args, CppIncludeBase);
       addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + Arch);
       addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + "backward");
     }
+    break;
+  }
 }

cfe/trunk/lib/Driver/Tools.cpp

if (llvm::zlib::isAvailable())
       CmdArgs.push_back("-compress-debug-sections");
     else
       D.Diag(diag::warn_debug_compression_unavailable);
   }
 }
 
 // Until ARM libraries are build separately, we have them all in one library
 static StringRef getArchNameForCompilerRTLib(const ToolChain &TC) {
-  if (TC.getTriple().isOSWindows() &&
-      !TC.getTriple().isWindowsItaniumEnvironment() &&
+  if (TC.getTriple().isWindowsMSVCEnvironment() &&
       TC.getArch() == llvm::Triple::x86)
     return "i386";
   if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb)
     return "arm";
   return TC.getArchName();
 }
 
 static SmallString<128> getCompilerRTLibDir(const ToolChain &TC) {

 
 SmallString<128> tools::getCompilerRT(const ToolChain &TC, StringRef Component,
                                       bool Shared) {
   const char *Env = TC.getTriple().getEnvironment() == llvm::Triple::Android
                         ? "-android"
                         : "";
 
   bool IsOSWindows = TC.getTriple().isOSWindows();
+  bool IsITANMSVCWindows = TC.getTriple().isWindowsMSVCEnvironment() ||
+                           TC.getTriple().isWindowsItaniumEnvironment();
   StringRef Arch = getArchNameForCompilerRTLib(TC);
-  const char *Prefix = IsOSWindows ? "" : "lib";
+  const char *Prefix = IsITANMSVCWindows ? "" : "lib";
   const char *Suffix =
-      Shared ? (IsOSWindows ? ".dll" : ".so") : (IsOSWindows ? ".lib" : ".a");
+      Shared ? (IsOSWindows ? ".dll" : ".so") : (IsITANMSVCWindows ? ".lib" : ".a");
 
   SmallString<128> Path = getCompilerRTLibDir(TC);
   llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
                                     Arch + Env + Suffix);
 
   return Path;
 }
 
if (Args.hasArg(options::OPT_gsplit_dwarf) &&
       getToolChain().getTriple().isOSLinux())
     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
                    SplitDebugName(Args, Inputs[0]));
 }
 
 static void AddLibgcc(const llvm::Triple &Triple, const Driver &D,
                       ArgStringList &CmdArgs, const ArgList &Args) {
   bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android;
+  bool isCygMing = Triple.isOSCygMing();
   bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) ||
                       Args.hasArg(options::OPT_static);
   if (!D.CCCIsCXX())
     CmdArgs.push_back("-lgcc");
 
   if (StaticLibgcc || isAndroid) {
     if (D.CCCIsCXX())
       CmdArgs.push_back("-lgcc");
   } else {
-    if (!D.CCCIsCXX())
+    if (!D.CCCIsCXX() && !isCygMing)
       CmdArgs.push_back("--as-needed");
     CmdArgs.push_back("-lgcc_s");
-    if (!D.CCCIsCXX())
+    if (!D.CCCIsCXX() && !isCygMing)
       CmdArgs.push_back("--no-as-needed");
   }
 
   if (StaticLibgcc && !isAndroid)
     CmdArgs.push_back("-lgcc_eh");
   else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX())
     CmdArgs.push_back("-lgcc");
 
SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
                    SplitDebugName(Args, Inputs[0]));
 }
 
 void MinGW::Linker::AddLibGCC(const ArgList &Args,
                               ArgStringList &CmdArgs) const {
   if (Args.hasArg(options::OPT_mthreads))
     CmdArgs.push_back("-lmingwthrd");
   CmdArgs.push_back("-lmingw32");
-  if (Args.hasArg(options::OPT_shared) ||
-      Args.hasArg(options::OPT_shared_libgcc) ||
-      !Args.hasArg(options::OPT_static_libgcc)) {
-    CmdArgs.push_back("-lgcc_s");
-    CmdArgs.push_back("-lgcc");
-  } else {
-    CmdArgs.push_back("-lgcc");
-    CmdArgs.push_back("-lgcc_eh");
-  }
+
+  // Add libgcc or compiler-rt.
+  AddRunTimeLibs(getToolChain(), getToolChain().getDriver(), CmdArgs, Args);
+
   CmdArgs.push_back("-lmoldname");
   CmdArgs.push_back("-lmingwex");
   CmdArgs.push_back("-lmsvcrt");
 }
 
 void MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                  const InputInfo &Output,
                                  const InputInfoList &Inputs,