Mingw-w64 driver for clang

[yaron.keren]

Summary

Improved rubenvb and Martell patch for enabling separate Mingw driver in clang.

[Alexpux]

Move mingw libraries adding to GCC part

[Alexpux]

Sorry, paste wrong previous content

[Alexpux]

Apply suggestions from http://reviews.llvm.org/D3420

[rnk]

lib/Driver/MinGWToolChain.cpp

37–41 ↗

(On Diff #13480)

Please wrap up this kind of ifdef in a helper, so we have fewer of them.

38 ↗

(On Diff #13480)

Looking next to the clang driver assumes that clang is part of the mingw installation, which is pretty limiting. I believe the Generic_GCC toolchain has some logic for locating "gcc" on PATH and looking relative to that. If it's not there, we should fall back to searching relative to the driver.

This is really nice because it means that all you have to do is to set up your environment for building things for MinGW (put your gcc compiler or cross-compiler on PATH), and then invoke clang from anywhere.

Does that sound reasonable?

lib/Driver/Tools.cpp

7197 ↗

(On Diff #13480)

Please put a space between the leading // and the comment text.

[yaron.keren]

"This is really nice because it means that all you have to do is to set up your environment for building things for MinGW (put your gcc compiler or cross-compiler on PATH), and then invoke clang from anywhere."

That's the best solution. Very easy to switch between gcc versions if needed, and no hard-coded assumptions where gcc is installed.

[Alexpux]

But here is another issue.
Under windows toolchains have 3 exception types:

• dward
• sjlj
• seh

Not understand how switch between exception types

lib/Driver/MinGWToolChain.cpp

38 ↗

(On Diff #13480)

You about "-gcc-toolchain" option?

Looking into GCC_Generic code I see that it completely can't detect GCC installations in the PATH under Windows.

[yaron.keren]

(added cfe-commits)

SJLJ is not supported at all under Windows.
DWARF works with under Win32.
SEH works (or will work?) under Win64.

The GCC_Generic will not work as-is on Windows, but the principle is the same, locate gcc.exe on the path and build include locations relative to it.

[Alexpux]

We apply our patch to enable SEH working on our toolchains

[yaron.keren]

Where can I see this SEH patch?

Could you contribute it to clang so you won't have to reapply it every time?

[Alexpux]

In D5268#19, @yaron.keren wrote:

Where can I see this SEH patch?

Could you contribute it to clang so you won't have to reapply it every time?

Patch is here:
https://github.com/Alexpux/MINGW-packages/blob/master/mingw-w64-clang/clang-win64-seh.patch

But it apply on top of Mingw driver patch. And you can't choose exceptions for 64 bit toolchains then. You get SEH by default. But probably it's good when 32bit SEH will be added to GCC. Borland patent is already expired.

[Alexpux]

But if SJLJ not working under Windows then SEH is only variant for 64-bit MINGW

[yaron.keren]

Thanks.

The llvm SEH patch

https://github.com/Alexpux/MINGW-packages/blob/master/mingw-w64-clang/llvm-win64-exceptions.patch

is already in the current code, so only the clang patch you linked is required.

We have an old revision for the clang patch here

http://reviews.llvm.org/D3419

the code may need minor fixes to current patch / current trunk. If you have the time to push it through.

[Alexpux]

Minor fixes

[Alexpux]

Add SEH code removed from clang-seh patch.

[Alexpux]

Override parent class functions.

[yaron.keren]

You can remove the // FIXME: comment in Driver.cpp.

[Alexpux]

Remove FIXME

[Alexpux]

I think we need remove subclassing from Generic_GCC and subclass from Toolchain as rubenvb do earlier. And to detect too chains in path write our own functions.

[Alexpux]

Looking into Driver.cpp I see that toolchains trying to find basing on env "COMPILER_PATH" not the "PATH". So seems this code need to change too if we want to find in PATH.

[rnk]

I think we need remove subclassing from Generic_GCC and subclass from Toolchain as rubenvb do earlier. And to detect too chains in path write our own functions.

That seems fine.

Looking into Driver.cpp I see that toolchains trying to find basing on env "COMPILER_PATH" not the "PATH". So seems this code need to change too if we want to find in PATH.

That's a surprise, but we should find a way to factor this out and parameterize it as necessary then. We don't need to inherit from Generic_GCC to reuse the same functionality.

[Alexpux]

In D5268#36, @rnk wrote:

I think we need remove subclassing from Generic_GCC and subclass from Toolchain as rubenvb do earlier. And to detect too chains in path write our own functions.

That seems fine.

Looking into Driver.cpp I see that toolchains trying to find basing on env "COMPILER_PATH" not the "PATH". So seems this code need to change too if we want to find in PATH.

That's a surprise, but we should find a way to factor this out and parameterize it as necessary then. We don't need to inherit from Generic_GCC to reuse the same functionality.

This functionality is from Driver itself not Generic_GCC

[martell]

Hi alexey,

Thanks for sending me an email on this.

I've been testing the 3.5.0 release on the Mingw-Packges that has this patch applied.
I'm getting these include paths which look really good

#include <...> search starts here:
C:\msys64\mingw64\bin\..\lib\clang\3.5.0\include
C:\msys64\mingw64\bin/../x86_64-w64-mingw32/include
End of search list.

There is one missing however which should be

C:\msys64\mingw64\bin/../include

You may have fixed this already but I said I'd leave a note here.
We can talk more about this on tomorrow on IRC when you are awake :)

Yaron just in case there is any issues i support this merge of this patch.

[Alexpux]

• Subclassing from ToolChain instead GCC_Generic
• Fix passing "--subsystem" to linker
• Fix commands priority passed to linker
• Fix adding unix paths to includes

[Alexpux]

Fixed for trunk version of clang

[rubenvb]

I want to test this both on MSYS2's toolchain and Arch Linux', but git master fails to compile for now (don't have the PC where it failed in front of me right now so can't give any details). I'll try again later.

The patch looks ok though, but I'll have to check if the configurations I tested before still show the same behavior. Subclassing GCC_Generic also adds /usr/include for Linux cross-compilation unconditionally, so it's good that that was reverted back.

[rubenvb]

I have tested basic functionality on Windows using the MinGW-Builds toolchains. Couldn't cleanly test the MSYS2 built ones, but I'm assuming they will function as well. Will try to test on Arch Linux tomorrow.

lib/Driver/MinGWToolChain.cpp

48 ↗

(On Diff #13622)

I chose the fast solution here. There really should be a better way to handle this. Although in the long run the GCC dependence should go away (once libc++ is a viable alternative). So really all that needs to be put here is a decent way to handle the error here (e.g. just a message that is output to the console, probably a diagnostic of some kind).

lib/Driver/ToolChains.h

764 ↗

(On Diff #13622)

This "override" needs to be removed. GCC complains about it, and it is right to do so.

[Alexpux]

In D5268#44, @rubenvb wrote:

I have tested basic functionality on Windows using the MinGW-Builds toolchains. Couldn't cleanly test the MSYS2 built ones, but I'm assuming they will function as well. Will try to test on Arch Linux tomorrow.

What problem with testing MSYS2 clang packages?

lib/Driver/ToolChains.h

764 ↗

(On Diff #13622)

I'm do it here as LLVM guys do for Generic_GCC.

[chandlerc]

I'm not a good reviewer here (I don't work on Windows) and Reid seems like an excellent reviewer.

[ismail]

@rnk Would you mind giving an updated review here? Would be nice to get this fixed.

[rnk]

Sorry for the delay. I'm still not convinced that the LLVM_ON_WIN32 ifdefs are really the behavior we want for clang, but holding this patch up isn't helping. We keep getting bug reports from users who don't know how to find their mingw installation.

lib/Driver/MinGWToolChain.cpp

38 ↗

(On Diff #13622)

It took me a while to remember, but I think my primary issue with this change is that this line here makes clang inside mingw behave wildly differently from clang outside mingw's bin directory, without any way for the user to say "my toolchain is here, please use it". They have to resort to -isystem and -L, which is lame.

Still, this is an improvement, and we should probably move ahead with it.

52 ↗

(On Diff #13622)

nit: Please make comments into complete sentences, with a leading uppercase letter and period.

What does "assume sysrooted compiler" mean anyway? It seems like you're really assuming that Clang is installed inside a mingw installation bin directory, and we should look relative to that for libs. The Linux case is the one that's looking relative to a sysroot, so far as I can tell.

194 ↗

(On Diff #13622)

Please run clang-format to avoid 80col+ lines.

[yaron.keren]

I totally agree with Reid, clang should work outside the mingw directory not only for us developers but as the default result of someone installing mingw-w64 at one location and then using the official LLVM installer to install clang at c:\Program Files (X86). This combination will not work with the clang in gcc bin assumption.

This assumption is not really required. I've been using the code below locally for some time. It's tested on Windows only though it's the same principle with Linux - using findProgramByName to find gcc instead of assuming it's the same dir.

MinGW::MinGW(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
    : ToolChain(D, Triple, Args) {
  getProgramPaths().push_back(getDriver().getInstalledDir());

  llvm::ErrorOr<std::string> GPPName = llvm::sys::findProgramByName("gcc");
  if (GPPName) {
    llvm::StringRef GPP = GPPName.get();
    Base = llvm::sys::path::parent_path(llvm::sys::path::parent_path(GPP));
  } else {
    Base = llvm::sys::path::parent_path(getDriver().getInstalledDir());
  }
  Base += llvm::sys::path::get_separator();
  Arch = getTriple().getArchName();
  Arch += "-w64-mingw32";
  Arch += llvm::sys::path::get_separator();
  llvm::SmallString<1024> LibDir(Base);
  llvm::sys::path::append(LibDir, "lib", "gcc", Arch);
  std::error_code EC;
  llvm::sys::fs::directory_iterator entry(LibDir.str(), EC);
  if (EC)
    return;
  GccLibDir = entry->path();
  // GccLibDir must precede Base/lib so that the
  // correct crtbegin.o ,cetend.o would be found.
  getFilePaths().push_back(GccLibDir);
  getFilePaths().push_back(Base + "lib");
  getFilePaths().push_back(Base + Arch + "lib");
}

The corresponding add include routines are (again tested on Windows only)

void MinGW::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
                                      ArgStringList &CC1Args) const {
  if (DriverArgs.hasArg(options::OPT_nostdinc))
    return;

  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;

  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");
}

void MinGW::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
                                         ArgStringList &CC1Args) const {
  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
      DriverArgs.hasArg(options::OPT_nostdincxx))
    return;

  llvm::SmallString<1024> IncludeDir(Base);
  llvm::sys::path::append(IncludeDir, Arch, "include", "c++");
  addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
  IncludeDir += llvm::sys::path::get_separator();
  addSystemInclude(DriverArgs, CC1Args, IncludeDir.str() + Arch);
  addSystemInclude(DriverArgs, CC1Args, IncludeDir.str() + "backward");
}

Please merge something along these lines into the patch so clang will be able to run outside the gcc bin directory.

[yaron.keren]

lib/Driver/Tools.cpp

7958 ↗

(On Diff #13622)

claimNoWarnArgs(Args);

should be added before this line like the other Assemble::ConstructJob functions.

[rnk]

This came up again on cfe-dev. We should at least get something in tree. Yaron, if you could put together a patch that merges in your change I'd be happy to review it. :)

[yaron.keren]

OK, here is an updated patch for ToT.

So no more hardcoded paths: all directories are based on gcc location, which must be on the PATH. This enables having several mingw distributions installed and switching between them by simply changing the PATH pointing to gcc.exe.

This patch was tested on Windows 7, with mingw-w64 {32,64} bits and the older mingw.org 32 bits.
It was not tested on Linux cross-compilation to Windows. It may still work since all paths are gcc relative.

[yaron.keren]

Fix for Cygnus C include path.

[ivan171]

Hi Yaron, what you think about using the --sysroot arg to specify where mingw is installed. I think it's more easier to change the mingw installation by simply changing the arg, than messing around with environment variables.

For example, when i want to target x64, i simply add '--sysroot=/c/Mingw64 -m64' to the command line, and it just works. If --sysroot is not specified, getInstalledDir's parent directory is used instead.

Anyway, this is just a suggestion. And thanks for working on this.

[rubenvb]

I think support for the --sysroot option should be kept, and it currently isn't.

For the rest it looks fine (and a lot more complete than what I first had). I haven't tested it yet anywhere though.

[yaron.keren]

For interactive work I prefer to change path since typing gcc at the command line finds the same one clang would find.

Anyhow, no problem, here is the patch with --sysroot support. If --sysroot is provided it is the base directory for gcc root. If not, clang will look for gcc in the path as the previous version. The changes are in MinGW constructor.

[yaron.keren]

Reduce nesting level in Base selection logic.

[rnk]

lgtm, thanks!

[yaron.keren]

Thanks!, committed revision 241241.

tools/clang/include/clang/Driver/Options.td

 def malign_functions_EQ : Joined<["-"], "malign-functions=">, Group<clang_ignored_m_Group>;
 def malign_loops_EQ : Joined<["-"], "malign-loops=">, Group<clang_ignored_m_Group>;
 def malign_jumps_EQ : Joined<["-"], "malign-jumps=">, Group<clang_ignored_m_Group>;
 def mfancy_math_387 : Flag<["-"], "mfancy-math-387">, Group<clang_ignored_m_Group>;
 def march_EQ : Joined<["-"], "march=">, Group<m_Group>;
 def masm_EQ : Joined<["-"], "masm=">, Group<m_Group>, Flags<[DriverOption]>;
 def mcmodel_EQ : Joined<["-"], "mcmodel=">, Group<m_Group>;
 def mconstant_cfstrings : Flag<["-"], "mconstant-cfstrings">, Group<clang_ignored_m_Group>;
+def mconsole : Joined<["-"], "mconsole">, Group<m_Group>, Flags<[DriverOption]>;
+def mwindows : Joined<["-"], "mwindows">, Group<m_Group>, Flags<[DriverOption]>;
+def mdll : Joined<["-"], "mdll">, Group<m_Group>, Flags<[DriverOption]>;
+def municode : Joined<["-"], "municode">, Group<m_Group>, Flags<[DriverOption]>;
+def mthreads : Joined<["-"], "mthreads">, Group<m_Group>, Flags<[DriverOption]>;
 def mcpu_EQ : Joined<["-"], "mcpu=">, Group<m_Group>;
 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group<m_Group>;
 def mfix_and_continue : Flag<["-"], "mfix-and-continue">, Group<clang_ignored_m_Group>;
 def mieee_fp : Flag<["-"], "mieee-fp">, Group<clang_ignored_m_Group>;
 def minline_all_stringops : Flag<["-"], "minline-all-stringops">, Group<clang_ignored_m_Group>;
 def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;
 def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>;
 def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>;

tools/clang/lib/Driver/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Option
   Support
   )
 
 add_clang_library(clangDriver
   Action.cpp
   Compilation.cpp
   CrossWindowsToolChain.cpp
   Driver.cpp
   DriverOptions.cpp
   Job.cpp
+  MinGWToolChain.cpp
   Multilib.cpp
   MSVCToolChain.cpp
   Phases.cpp
   SanitizerArgs.cpp
   Tool.cpp
   ToolChain.cpp
   ToolChains.cpp
   Tools.cpp
   Types.cpp
 
   DEPENDS
   ClangDriverOptions
 
   LINK_LIBS
   clangBasic
   )

tools/clang/lib/Driver/Driver.cpp

         if (Target.isOSBinFormatELF())
           TC = new toolchains::Generic_ELF(*this, Target, Args);
         else if (Target.isOSBinFormatMachO())
           TC = new toolchains::MachO(*this, Target, Args);
         else
           TC = new toolchains::Generic_GCC(*this, Target, Args);
         break;
       case llvm::Triple::GNU:
-        // FIXME: We need a MinGW toolchain.  Use the default Generic_GCC
-        // toolchain for now as the default case would below otherwise.
-        if (Target.isOSBinFormatELF())
-          TC = new toolchains::Generic_ELF(*this, Target, Args);
-        else
-          TC = new toolchains::Generic_GCC(*this, Target, Args);
+        TC = new toolchains::MinGW(*this, Target, Args);
         break;
       case llvm::Triple::Itanium:
         TC = new toolchains::CrossWindowsToolChain(*this, Target, Args);
         break;
       case llvm::Triple::MSVC:
       case llvm::Triple::UnknownEnvironment:
         TC = new toolchains::MSVCToolChain(*this, Target, Args);
         break;

tools/clang/lib/Driver/MinGWToolChain.cpp

+//===--- MinGWToolChain.cpp - MinGWToolChain Implementation
+//-----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ToolChains.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+using namespace clang::diag;
+using namespace clang::driver;
+using namespace clang::driver::toolchains;
+using namespace clang;
+using namespace llvm::opt;
+
+MinGW::MinGW(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
+    : ToolChain(D, Triple, Args) {
+  getProgramPaths().push_back(getDriver().getInstalledDir());
+
+  if (getDriver().SysRoot.size())
+    Base = getDriver().SysRoot;
+  else if (llvm::ErrorOr<std::string> GPPName =
+               llvm::sys::findProgramByName("gcc"))
+    Base = llvm::sys::path::parent_path(
+        llvm::sys::path::parent_path(GPPName.get()));
+  else
+    Base = llvm::sys::path::parent_path(getDriver().getInstalledDir());
+  Base += llvm::sys::path::get_separator();
+  llvm::SmallString<1024> LibDir(Base);
+  llvm::sys::path::append(LibDir, "lib", "gcc");
+  LibDir += llvm::sys::path::get_separator();
+
+  // First look for mingw-w64.
+  Arch = getTriple().getArchName();
+  Arch += "-w64-mingw32";
+  std::error_code EC;
+  llvm::sys::fs::directory_iterator MingW64Entry(LibDir + Arch, EC);
+  if (!EC) {
+    GccLibDir = MingW64Entry->path();
+  } else {
+    // If mingw-w64 not found, try looking for mingw.org.
+    Arch = "mingw32";
+    llvm::sys::fs::directory_iterator MingwOrgEntry(LibDir + Arch, EC);
+    if (!EC)
+      GccLibDir = MingwOrgEntry->path();
+  }
+  Arch += llvm::sys::path::get_separator();
+  // GccLibDir must precede Base/lib so that the
+  // correct crtbegin.o ,cetend.o would be found.
+  getFilePaths().push_back(GccLibDir);
+  getFilePaths().push_back(Base + "lib");
+  getFilePaths().push_back(Base + Arch + "lib");
+}
+
+bool MinGW::IsIntegratedAssemblerDefault() const { return true; }
+
+Tool *MinGW::getTool(Action::ActionClass AC) const {
+  switch (AC) {
+  case Action::PreprocessJobClass:
+    if (!Preprocessor)
+      Preprocessor.reset(new tools::gcc::Preprocessor(*this));
+    return Preprocessor.get();
+  case Action::CompileJobClass:
+    if (!Compiler)
+      Compiler.reset(new tools::gcc::Compiler(*this));
+    return Compiler.get();
+  default:
+    return ToolChain::getTool(AC);
+  }
+}
+
+Tool *MinGW::buildAssembler() const {
+  return new tools::MinGW::Assembler(*this);
+}
+
+Tool *MinGW::buildLinker() const { return new tools::MinGW::Linker(*this); }
+
+bool MinGW::IsUnwindTablesDefault() const {
+  return getArch() == llvm::Triple::x86_64;
+}
+
+bool MinGW::isPICDefault() const { return getArch() == llvm::Triple::x86_64; }
+
+bool MinGW::isPIEDefault() const { return false; }
+
+bool MinGW::isPICDefaultForced() const {
+  return getArch() == llvm::Triple::x86_64;
+}
+
+bool MinGW::UseSEHExceptions() const {
+  return getArch() == llvm::Triple::x86_64;
+}
+
+void MinGW::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
+                                      ArgStringList &CC1Args) const {
+  if (DriverArgs.hasArg(options::OPT_nostdinc))
+    return;
+
+  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;
+
+  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");
+}
+
+void MinGW::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
+                                         ArgStringList &CC1Args) const {
+  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+      DriverArgs.hasArg(options::OPT_nostdincxx))
+    return;
+
+  llvm::SmallString<1024> IncludeDir;
+  for (bool MingW64 : {true, false}) {
+    if (MingW64)
+      IncludeDir = Base + Arch;
+    else
+      IncludeDir = GccLibDir;
+    llvm::sys::path::append(IncludeDir, "include", "c++");
+    addSystemInclude(DriverArgs, CC1Args, IncludeDir.str());
+    IncludeDir += llvm::sys::path::get_separator();
+    addSystemInclude(DriverArgs, CC1Args, IncludeDir.str() + Arch);
+    addSystemInclude(DriverArgs, CC1Args, IncludeDir.str() + "backward");
+  }
+}

tools/clang/lib/Driver/ToolChains.h

 
   bool IsIntegratedAssemblerDefault() const override { return true; }
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 };
 
+class LLVM_LIBRARY_VISIBILITY MinGW : public ToolChain {
+public:
+  MinGW(const Driver &D, const llvm::Triple &Triple,
+        const llvm::opt::ArgList &Args);
+
+  bool IsIntegratedAssemblerDefault() const override;
+  bool IsUnwindTablesDefault() const override;
+  bool isPICDefault() const override;
+  bool isPIEDefault() const override;
+  bool isPICDefaultForced() const override;
+  bool UseSEHExceptions() const;
+
+  void
+  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                            llvm::opt::ArgStringList &CC1Args) const override;
+  void AddClangCXXStdlibIncludeArgs(
+      const llvm::opt::ArgList &DriverArgs,
+      llvm::opt::ArgStringList &CC1Args) const override;
+
+protected:
+  Tool *getTool(Action::ActionClass AC) const override;
+  Tool *buildLinker() const override;
+  Tool *buildAssembler() const override;
+
+private:
+  std::string Base;
+  std::string GccLibDir;
+  std::string Arch;
+  mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocessor;
+  mutable std::unique_ptr<tools::gcc::Compiler> Compiler;
+};
+
 class LLVM_LIBRARY_VISIBILITY OpenBSD : public Generic_ELF {
 public:
   OpenBSD(const Driver &D, const llvm::Triple &Triple,
           const llvm::opt::ArgList &Args);
 
   bool IsMathErrnoDefault() const override { return false; }
   bool IsObjCNonFragileABIDefault() const override { return true; }
   bool isPIEDefault() const override { return true; }

tools/clang/lib/Driver/Tools.h

     std::unique_ptr<Command> GetCommand(Compilation &C, const JobAction &JA,
                                         const InputInfo &Output,
                                         const InputInfoList &Inputs,
                                         const llvm::opt::ArgList &TCArgs,
                                         const char *LinkingOutput) const;
   };
 } // end namespace visualstudio
 
+/// MinGW -- Directly call GNU Binutils assembler and linker
+namespace MinGW {
+class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+public:
+  Assembler(const ToolChain &TC) : Tool("MinGW::Assemble", "assembler", TC) {}
+
+  bool hasIntegratedCPP() const override { return false; }
+
+  void ConstructJob(Compilation &C, const JobAction &JA,
+                    const InputInfo &Output, const InputInfoList &Inputs,
+                    const llvm::opt::ArgList &TCArgs,
+                    const char *LinkingOutput) const override;
+};
+
+class LLVM_LIBRARY_VISIBILITY Linker : public Tool {
+public:
+  Linker(const ToolChain &TC) : Tool("MinGW::Linker", "linker", TC) {}
+
+  bool hasIntegratedCPP() const override { return false; }
+  bool isLinkJob() const override { return true; }
+
+  void ConstructJob(Compilation &C, const JobAction &JA,
+                    const InputInfo &Output, const InputInfoList &Inputs,
+                    const llvm::opt::ArgList &TCArgs,
+                    const char *LinkingOutput) const override;
+
+private:
+  void AddLibGCC(const llvm::opt::ArgList &Args, ArgStringList &CmdArgs) const;
+};
+} // end namespace MinGW
+
 namespace arm {
   StringRef getARMFloatABI(const Driver &D, const llvm::opt::ArgList &Args,
                          const llvm::Triple &Triple);
 }
 namespace XCore {
 // For XCore, we do not need to instantiate tools for PreProcess, PreCompile and
 // Compile.
 // We simply use "clang -cc1" for those actions.

tools/clang/lib/Driver/Tools.cpp

 
   const Driver &D = getToolChain().getDriver();
   std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
                                                 D.getClangProgramPath());
   return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
                                     CmdArgs);
 }
 
+/// MinGW Tools
+void MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
+                                    const InputInfo &Output,
+                                    const InputInfoList &Inputs,
+                                    const ArgList &Args,
+                                    const char *LinkingOutput) const {
+  claimNoWarnArgs(Args);
+  ArgStringList CmdArgs;
+
+  if (getToolChain().getArch() == llvm::Triple::x86) {
+    CmdArgs.push_back("--32");
+  } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
+    CmdArgs.push_back("--64");
+  }
+
+  Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
+
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Output.getFilename());
+
+  for (const auto &II : Inputs)
+    CmdArgs.push_back(II.getFilename());
+
+  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
+
+  if (Args.hasArg(options::OPT_gsplit_dwarf))
+    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");
+  }
+  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,
+                                 const ArgList &Args,
+                                 const char *LinkingOutput) const {
+  const ToolChain &TC = getToolChain();
+  const Driver &D = TC.getDriver();
+  // const SanitizerArgs &Sanitize = TC.getSanitizerArgs();
+
+  ArgStringList CmdArgs;
+
+  // Silence warning for "clang -g foo.o -o foo"
+  Args.ClaimAllArgs(options::OPT_g_Group);
+  // and "clang -emit-llvm foo.o -o foo"
+  Args.ClaimAllArgs(options::OPT_emit_llvm);
+  // and for "clang -w foo.o -o foo". Other warning options are already
+  // handled somewhere else.
+  Args.ClaimAllArgs(options::OPT_w);
+
+  if (!D.SysRoot.empty())
+    CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
+
+  if (Args.hasArg(options::OPT_s))
+    CmdArgs.push_back("-s");
+
+  CmdArgs.push_back("-m");
+  if (TC.getArch() == llvm::Triple::x86)
+    CmdArgs.push_back("i386pe");
+  if (TC.getArch() == llvm::Triple::x86_64)
+    CmdArgs.push_back("i386pep");
+
+  if (Args.hasArg(options::OPT_mwindows)) {
+    CmdArgs.push_back("--subsystem");
+    CmdArgs.push_back("windows");
+  } else if (Args.hasArg(options::OPT_mconsole)) {
+    CmdArgs.push_back("--subsystem");
+    CmdArgs.push_back("console");
+  }
+
+  if (Args.hasArg(options::OPT_static))
+    CmdArgs.push_back("-Bstatic");
+  else {
+    if (Args.hasArg(options::OPT_mdll))
+      CmdArgs.push_back("--dll");
+    else if (Args.hasArg(options::OPT_shared))
+      CmdArgs.push_back("--shared");
+    CmdArgs.push_back("-Bdynamic");
+    if (Args.hasArg(options::OPT_mdll) || Args.hasArg(options::OPT_shared)) {
+      CmdArgs.push_back("-e");
+      if (TC.getArch() == llvm::Triple::x86)
+        CmdArgs.push_back("_DllMainCRTStartup@12");
+      else
+        CmdArgs.push_back("DllMainCRTStartup");
+      CmdArgs.push_back("--enable-auto-image-base");
+    }
+  }
+
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Output.getFilename());
+
+  Args.AddAllArgs(CmdArgs, options::OPT_e);
+  // FIXME: add -N, -n flags
+  Args.AddLastArg(CmdArgs, options::OPT_r);
+  Args.AddLastArg(CmdArgs, options::OPT_s);
+  Args.AddLastArg(CmdArgs, options::OPT_t);
+  Args.AddAllArgs(CmdArgs, options::OPT_u_Group);
+  Args.AddLastArg(CmdArgs, options::OPT_Z_Flag);
+
+  if (!Args.hasArg(options::OPT_nostdlib) &&
+      !Args.hasArg(options::OPT_nostartfiles)) {
+    if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_mdll)) {
+      CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));
+    } else {
+      if (Args.hasArg(options::OPT_municode))
+        CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2u.o")));
+      else
+        CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));
+    }
+    if (Args.hasArg(options::OPT_pg))
+      CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("gcrt2.o")));
+    CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
+  }
+
+  Args.AddAllArgs(CmdArgs, options::OPT_L);
+  const ToolChain::path_list Paths = TC.getFilePaths();
+  for (const auto &Path : Paths)
+    CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + Path));
+
+  AddLinkerInputs(TC, Inputs, Args, CmdArgs);
+
+  // TODO: Add ASan stuff here
+
+  // TODO: Add profile stuff here
+
+  if (D.CCCIsCXX() && !Args.hasArg(options::OPT_nostdlib) &&
+      !Args.hasArg(options::OPT_nodefaultlibs)) {
+    bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) &&
+                               !Args.hasArg(options::OPT_static);
+    if (OnlyLibstdcxxStatic)
+      CmdArgs.push_back("-Bstatic");
+    TC.AddCXXStdlibLibArgs(Args, CmdArgs);
+    if (OnlyLibstdcxxStatic)
+      CmdArgs.push_back("-Bdynamic");
+  }
+
+  if (!Args.hasArg(options::OPT_nostdlib)) {
+    if (!Args.hasArg(options::OPT_nodefaultlibs)) {
+      if (Args.hasArg(options::OPT_static))
+        CmdArgs.push_back("--start-group");
+
+      if (Args.hasArg(options::OPT_fstack_protector) ||
+          Args.hasArg(options::OPT_fstack_protector_strong) ||
+          Args.hasArg(options::OPT_fstack_protector_all)) {
+        CmdArgs.push_back("-lssp_nonshared");
+        CmdArgs.push_back("-lssp");
+      }
+      if (Args.hasArg(options::OPT_fopenmp))
+        CmdArgs.push_back("-lgomp");
+
+      AddLibGCC(Args, CmdArgs);
+
+      if (Args.hasArg(options::OPT_pg))
+        CmdArgs.push_back("-lgmon");
+
+      // FIXME: what to do about pthreads library?
+      // Currently required for OpenMP and posix-threading libgcc, 
+      // does not exists in mingw.org.
+      //CmdArgs.push_back("-lpthread");
+
+      // add system libraries
+      if (Args.hasArg(options::OPT_mwindows)) {
+        CmdArgs.push_back("-lgdi32");
+        CmdArgs.push_back("-lcomdlg32");
+      }
+      CmdArgs.push_back("-ladvapi32");
+      CmdArgs.push_back("-lshell32");
+      CmdArgs.push_back("-luser32");
+      CmdArgs.push_back("-lkernel32");
+
+      if (Args.hasArg(options::OPT_static))
+        CmdArgs.push_back("--end-group");
+      else
+        AddLibGCC(Args, CmdArgs);
+    }
+
+    if (!Args.hasArg(options::OPT_nostartfiles)) {
+      // Add crtfastmath.o if available and fast math is enabled.
+      TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
+
+      CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
+    }
+  }
+  const char *Exec = Args.MakeArgString(TC.GetProgramPath("ld"));
+  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs));
+}
+
 /// XCore Tools
 // We pass assemble and link construction to the xcc tool.
 
 void XCore::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                     const InputInfo &Output,
                                     const InputInfoList &Inputs,
                                     const ArgList &Args,
                                     const char *LinkingOutput) const {

tools/clang/lib/Frontend/InitHeaderSearch.cpp

void AddGnuCPlusPlusIncludePaths(StringRef Base,
                                    const llvm::Triple &triple);
 
   /// AddMinGWCPlusPlusIncludePaths - Add the necessary paths to support a MinGW
   ///  libstdc++.
   void AddMinGWCPlusPlusIncludePaths(StringRef Base,
                                      StringRef Arch,
                                      StringRef Version);
 
-  /// AddMinGW64CXXPaths - Add the necessary paths to support
-  /// libstdc++ of x86_64-w64-mingw32 aka mingw-w64.
-  void AddMinGW64CXXPaths(StringRef Base,
-                          StringRef Version);
-
   // AddDefaultCIncludePaths - Add paths that should always be searched.
   void AddDefaultCIncludePaths(const llvm::Triple &triple,
                                const HeaderSearchOptions &HSOpts);
 
   // AddDefaultCPlusPlusIncludePaths -  Add paths that should be searched when
   //  compiling c++.
   void AddDefaultCPlusPlusIncludePaths(const llvm::Triple &triple,
                                        const HeaderSearchOptions &HSOpts);
void InitHeaderSearch::AddMinGWCPlusPlusIncludePaths(StringRef Base,
   AddPath(Base + "/" + Arch + "/" + Version + "/include/c++",
           CXXSystem, false);
   AddPath(Base + "/" + Arch + "/" + Version + "/include/c++/" + Arch,
           CXXSystem, false);
   AddPath(Base + "/" + Arch + "/" + Version + "/include/c++/backward",
           CXXSystem, false);
 }
 
-void InitHeaderSearch::AddMinGW64CXXPaths(StringRef Base,
-                                          StringRef Version) {
-  // Assumes Base is HeaderSearchOpts' ResourceDir
-  AddPath(Base + "/../../../include/c++/" + Version,
-          CXXSystem, false);
-  AddPath(Base + "/../../../include/c++/" + Version + "/x86_64-w64-mingw32",
-          CXXSystem, false);
-  AddPath(Base + "/../../../include/c++/" + Version + "/i686-w64-mingw32",
-          CXXSystem, false);
-  AddPath(Base + "/../../../include/c++/" + Version + "/backward",
-          CXXSystem, false);
-}
-
 void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
                                             const HeaderSearchOptions &HSOpts) {
   llvm::Triple::OSType os = triple.getOS();
 
   if (HSOpts.UseStandardSystemIncludes) {
     switch (os) {
     case llvm::Triple::CloudABI:
     case llvm::Triple::FreeBSD:
     case llvm::Triple::NetBSD:
     case llvm::Triple::OpenBSD:
     case llvm::Triple::Bitrig:
     case llvm::Triple::NaCl:
       break;
+    case llvm::Triple::Win32:
+      if (triple.getEnvironment() != llvm::Triple::Cygnus)
+        break;
     default:
       // FIXME: temporary hack: hard-coded paths.
       AddPath("/usr/local/include", System, false);
       break;
     }
   }
 
   // Builtin includes use #include_next directives and should be positioned
case llvm::Triple::RTEMS:
     break;
   case llvm::Triple::Win32:
     switch (triple.getEnvironment()) {
     default: llvm_unreachable("Include management is handled in the driver.");
     case llvm::Triple::Cygnus:
       AddPath("/usr/include/w32api", System, false);
       break;
     case llvm::Triple::GNU:
-      // mingw-w64 crt include paths
-      // <sysroot>/i686-w64-mingw32/include
-      SmallString<128> P = StringRef(HSOpts.ResourceDir);
-      llvm::sys::path::append(P, "../../../i686-w64-mingw32/include");
-      AddPath(P, System, false);
-
-      // <sysroot>/x86_64-w64-mingw32/include
-      P.resize(HSOpts.ResourceDir.size());
-      llvm::sys::path::append(P, "../../../x86_64-w64-mingw32/include");
-      AddPath(P, System, false);
-
-      // mingw.org crt include paths
-      // <sysroot>/include
-      P.resize(HSOpts.ResourceDir.size());
-      llvm::sys::path::append(P, "../../../include");
-      AddPath(P, System, false);
-      AddPath("/mingw/include", System, false);
-#if defined(LLVM_ON_WIN32)
-      AddPath("c:/mingw/include", System, false); 
-#endif
       break;
     }
     break;
   default:
     break;
   }
 
   switch (os) {
case llvm::Triple::Win32:
     case llvm::Triple::Cygnus:
       // Cygwin-1.7
       AddMinGWCPlusPlusIncludePaths("/usr/lib/gcc", "i686-pc-cygwin", "4.7.3");
       AddMinGWCPlusPlusIncludePaths("/usr/lib/gcc", "i686-pc-cygwin", "4.5.3");
       AddMinGWCPlusPlusIncludePaths("/usr/lib/gcc", "i686-pc-cygwin", "4.3.4");
       // g++-4 / Cygwin-1.5
       AddMinGWCPlusPlusIncludePaths("/usr/lib/gcc", "i686-pc-cygwin", "4.3.2");
       break;
-    case llvm::Triple::GNU:
-      // mingw-w64 C++ include paths (i686-w64-mingw32 and x86_64-w64-mingw32)
-      AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.7.0");
-      AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.7.1");
-      AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.7.2");
-      AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.7.3");
-      AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.8.0");
-      AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.8.1");
-      AddMinGW64CXXPaths(HSOpts.ResourceDir, "4.8.2");
-      // mingw.org C++ include paths
-#if defined(LLVM_ON_WIN32)
-      AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.7.0");
-      AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.7.1");
-      AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.7.2");
-      AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.7.3");
-      AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.8.0");
-      AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.8.1");
-      AddMinGWCPlusPlusIncludePaths("c:/MinGW/lib/gcc", "mingw32", "4.8.2");
-#endif
-      break;
     }
+    break;
   case llvm::Triple::DragonFly:
     if (llvm::sys::fs::exists("/usr/lib/gcc47"))
       AddPath("/usr/include/c++/4.7", CXXSystem, false);
     else
       AddPath("/usr/include/c++/4.4", CXXSystem, false);
     break;
   case llvm::Triple::OpenBSD: {
     std::string t = triple.getTriple();
void InitHeaderSearch::AddDefaultIncludePaths(const LangOptions &Lang,
   switch (triple.getOS()) {
   default:
     break; // Everything else continues to use this routine's logic.
 
   case llvm::Triple::Linux:
     return;
 
   case llvm::Triple::Win32:
-    if (triple.getEnvironment() == llvm::Triple::MSVC ||
-        triple.getEnvironment() == llvm::Triple::Itanium ||
+    if (triple.getEnvironment() != llvm::Triple::Cygnus ||
         triple.isOSBinFormatMachO())
       return;
     break;
   }
 
   if (Lang.CPlusPlus && HSOpts.UseStandardCXXIncludes &&
       HSOpts.UseStandardSystemIncludes) {
     if (HSOpts.UseLibcxx) {