Clang: add support to mingw driver for compiler-rt, libc++ and lld

[martell]

Summary

In terms of clang and mingw-w64 going forward I think the goal should be to get clang working without gcc.
I have achieved this but currently we look relative to the gcc program.
I need input on how to best change this

The patch does several things atm

1. it adds the -no-pthread option

while mingw doesn't add -lpthread by default mingw-w64 does.
I saw a note recently in the source with a FIXME on how to handle this.

I think the best way to fix this would be to set a bool in the driver.
Currently we check for mingw-w64's folder layout and then mingw org if that fails
We could set the bool here and use that to decide if we should use pthread by default ?

Ideally however mingw-w64 should support c11 threads and we should not link to pthreads by default but thats not down to us
I may work on this in the future from that end.

mingw-w64 is provided with a -no-pthread option by gcc because of this inconsistency and it is needed to build mingw-w64 from source.
To have clang be able to build mingw-w64 we nned to handle / ignore this option without ending complination.

2. It adds support for using compiler-rt and sets it to the default

The user can override this with -rtlib=libgcc if they want that but I think the default should be a clang standalone toolchain
Relative compiler-rt diff http://reviews.llvm.org/D11085

3. It adds support for using libc++ and sets it to the default

The user can override this with -stdlib=libstdc++ if they want that but I think the default should be libc++ for that standalone toolchain

4. It adds support for lld but does not set it to the default because it is not ready for gnu mode on windows

I have submitted patches to lld to support this

5. It adds support for thumb2pe machine for the linker

I have patches for binutils that will be merged once I fill in my FSF waiver and get it merged

Thanks for taking the time to read :)

[yaron.keren]

Could you break this into five independent patches so they may be discussed (and approved) one by one?

[martell]

In D11077#202176, @yaron.keren wrote:

Could you break this into five independent patches so they may be discussed (and approved) one by one?

Sure, I'll abandon this once the others are done

EDIT:

I think it would be best to have 2 and 3 in the same patch because they both depend on common lines of code.

To get them merged I will leave the default as libstdc++ and libgcc
I will mark it as adding support for -rtlib and -stdlib to the driver

Also 4 and 5 would probably best put together also as lld is the program that came up with the name thumb2pe and there is no code in binutils for this atm

[martell]

Update 1,4 and 5 have been merged
Will do a patch for 2,3 and then abandon this

[martell]

All the components of this have been merged :)
Thanks guys

include/clang/Driver/Options.td

 def pthreads : Flag<["-"], "pthreads">;
 def pthread : Flag<["-"], "pthread">, Flags<[CC1Option]>,
   HelpText<"Support POSIX threads in generated code">;
+def no_pthread : Flag<["-"], "no-pthread">, Flags<[CC1Option]>;
 def p : Flag<["-"], "p">;
 def pie : Flag<["-"], "pie">;
 def read__only__relocs : Separate<["-"], "read_only_relocs">;

lib/Driver/MinGWToolChain.cpp

 
 #include "ToolChains.h"
 #include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/FileSystem.h"

   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
     return;
 
-  llvm::SmallString<1024> IncludeDir(GccLibDir);
-  llvm::sys::path::append(IncludeDir, "include");
-  addSystemInclude(DriverArgs, CC1Args, IncludeDir.c_str());
-  IncludeDir += "-fixed";
-  addSystemInclude(DriverArgs, CC1Args, IncludeDir.c_str());
   addSystemInclude(DriverArgs, CC1Args, Base + Arch + "include");
   addSystemInclude(DriverArgs, CC1Args, Base + "include");
+
+  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";
+    addSystemInclude(DriverArgs, CC1Args, IncludeDir.c_str());
+  }
 }
 
 void MinGW::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,

       DriverArgs.hasArg(options::OPT_nostdincxx))
     return;
 
-  // C++ includes may be found in several locations depending on distribution.
-  // mingw-w64 mingw-builds: $sysroot/i686-w64-mingw32/include/c++.
-  // mingw-w64 msys2:        $sysroot/include/c++/4.9.2
-  // mingw.org:              GccLibDir/include/c++
-  llvm::SmallVector<llvm::SmallString<1024>, 3> CppIncludeBases;
-  CppIncludeBases.emplace_back(Base);
-  llvm::sys::path::append(CppIncludeBases[0], Arch, "include", "c++");
-  CppIncludeBases.emplace_back(Base);
-  llvm::sys::path::append(CppIncludeBases[1], "include", "c++", Ver);
-  CppIncludeBases.emplace_back(GccLibDir);
-  llvm::sys::path::append(CppIncludeBases[2], "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");
+  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:
+    // C++ includes may be found in several locations depending on distribution.
+    // mingw-w64 mingw-builds: $sysroot/i686-w64-mingw32/include/c++.
+    // mingw-w64 msys2:        $sysroot/include/c++/4.9.2
+    // mingw.org:              GccLibDir/include/c++
+    llvm::SmallVector<llvm::SmallString<1024>, 3> CppIncludeBases;
+    CppIncludeBases.emplace_back(Base);
+    llvm::sys::path::append(CppIncludeBases[0], Arch, "include", "c++");
+    CppIncludeBases.emplace_back(Base);
+    llvm::sys::path::append(CppIncludeBases[1], "include", "c++", Ver);
+    CppIncludeBases.emplace_back(GccLibDir);
+    llvm::sys::path::append(CppIncludeBases[2], "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;
+  }
+}
+
+void MinGW::AddCXXStdlibLibArgs(const llvm::opt::ArgList &DriverArgs,
+                                llvm::opt::ArgStringList &CmdArgs) const {
+  switch (GetCXXStdlibType(DriverArgs)) {
+  case ToolChain::CST_Libcxx:
+    CmdArgs.push_back("-lc++");
+    CmdArgs.push_back("-lc++abi");
+    break;
+
+  case ToolChain::CST_Libstdcxx:
+    CmdArgs.push_back("-lstdc++");
+    break;
+  }
+}
+
+ToolChain::RuntimeLibType MinGW::GetRuntimeLibType(const ArgList &Args) const{
+  if (Arg *A = Args.getLastArg(options::OPT_rtlib_EQ)) {
+    StringRef Value = A->getValue();
+    if (Value == "compiler-rt")
+      return ToolChain::RLT_CompilerRT;
+    if (Value == "libgcc")
+      return ToolChain::RLT_Libgcc;
+    getDriver().Diag(diag::err_drv_invalid_rtlib_name)
+      << A->getAsString(Args);
+  }
+  return ToolChain::RLT_CompilerRT;
+}
+
+ToolChain::CXXStdlibType MinGW::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;
+    getDriver().Diag(diag::err_drv_invalid_stdlib_name)
+      << A->getAsString(Args);
   }
+  return ToolChain::CST_Libcxx;
 }

lib/Driver/ToolChains.h

   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;
+
+  CXXStdlibType GetCXXStdlibType(
+      const llvm::opt::ArgList &Args) const override;
+  RuntimeLibType GetRuntimeLibType(
+      const llvm::opt::ArgList &Args) const override;
 
 protected:
   Tool *getTool(Action::ActionClass AC) const override;

lib/Driver/Tools.h

                     const char *LinkingOutput) const override;
 
 private:
-  void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const;
+  void AddRuntime(const ToolChain &TC, const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const;
 };
 } // end namespace MinGW
 

lib/Driver/Tools.cpp

 
 // 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)

                         : "";
 
   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 + "-" +

                    SplitDebugName(Args, Inputs[0]));
 }
 
-void MinGW::Linker::AddLibGCC(const ArgList &Args,
+void MinGW::Linker::AddRuntime(const ToolChain &TC, 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");
+
+  switch (TC.GetRuntimeLibType(Args)) {
+  case ToolChain::RLT_CompilerRT:
+    CmdArgs.push_back(Args.MakeArgString(getCompilerRT(TC, "builtins")));
+    break;
+
+  case ToolChain::RLT_Libgcc:
+    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");
+    }
+    break;
   }
+
   CmdArgs.push_back("-lmoldname");
   CmdArgs.push_back("-lmingwex");
   CmdArgs.push_back("-lmsvcrt");

   // handled somewhere else.
   Args.ClaimAllArgs(options::OPT_w);
 
+  StringRef Linker = Args.getLastArgValue(options::OPT_fuse_ld_EQ, "ld");
+  if (Linker.equals_lower("lld")) {
+    CmdArgs.push_back("-flavor");
+    CmdArgs.push_back("gnu");
+  }
+
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 

     CmdArgs.push_back("i386pe");
   if (TC.getArch() == llvm::Triple::x86_64)
     CmdArgs.push_back("i386pep");
+  if (TC.getArch() == llvm::Triple::arm)
+    CmdArgs.push_back("thumb2pe");
 
   if (Args.hasArg(options::OPT_mwindows)) {
     CmdArgs.push_back("--subsystem");

       if (Args.hasArg(options::OPT_fopenmp))
         CmdArgs.push_back("-lgomp");
 
-      AddLibGCC(Args, CmdArgs);
+      AddRuntime(TC, Args, CmdArgs);
 
       if (Args.hasArg(options::OPT_pg))
         CmdArgs.push_back("-lgmon");
 
-      if (Args.hasArg(options::OPT_pthread))
+      if (Args.hasArg(options::OPT_pthread)  &&
+          !Args.hasArg(options::OPT_no_pthread))
         CmdArgs.push_back("-lpthread");
 
       // add system libraries

       if (Args.hasArg(options::OPT_static))
         CmdArgs.push_back("--end-group");
       else
-        AddLibGCC(Args, CmdArgs);
+        if (!Linker.equals_lower("lld"))
+          AddRuntime(TC, Args, CmdArgs);
     }
 
     if (!Args.hasArg(options::OPT_nostartfiles)) {

       CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
     }
   }
-  const char *Exec = Args.MakeArgString(TC.GetProgramPath("ld"));
+  const char *Exec = Args.MakeArgString(TC.GetProgramPath(Linker.data()));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
 }