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

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

38

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

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

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

49

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

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

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

39

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.

53

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.

195

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

8129

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.

b/include/clang/Driver/Options.td

 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>;

lib/Driver/CMakeLists.txt

   ToolChain.cpp
   ToolChains.cpp
   WindowsToolChain.cpp
+  MinGWToolChain.cpp
   Tools.cpp
   Types.cpp
   )

lib/Driver/Driver.cpp

       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::MSVC:
       case llvm::Triple::UnknownEnvironment:

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/Basic/CharInfo.h"
+#include "clang/Basic/DiagnosticIDs.h"
+#include "clang/Basic/Version.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/ErrorHandling.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)
+  : Generic_GCC(D, Triple, Args) {
+  //TODO: libc++ directory
+
+  // Get GCC version string for library and header directories
+  const std::string GCClibdir =
+#ifdef LLVM_ON_WIN32
+          getDriver().Dir + "/../lib/gcc/" + getTriple().getArchName().str() + "-w64-mingw32";
+#else
+          getDriver().SysRoot + "/usr/lib/gcc/" + getTriple().getArchName().str() + "-w64-mingw32";
+#endif
+  if (llvm::sys::fs::exists(GCClibdir)) {
+    // Find subdirectory, should be the version of MinGW-w64 GCC
+    std::error_code EC;
+    llvm::sys::fs::directory_iterator entry(StringRef(GCClibdir), EC);
+    if (!EC)
+      GCCVersion = llvm::sys::path::filename(entry->path());
+    //TODO report error: "no MinGW-w64 GCC installation found"
+  }
+
+#ifdef LLVM_ON_WIN32
+  // assume sysrooted compiler
+  getFilePaths().push_back(getDriver().Dir + "/../lib");
+  getFilePaths().push_back(getDriver().Dir + "/../" + getTriple().getArchName().str() + "-w64-mingw32"
+                           + "/lib");
+  getFilePaths().push_back(getDriver().Dir + "/../lib/gcc/"
+                           + getTriple().getArchName().str() + "-w64-mingw32" + "/" + GCCVersion);
+
+#else
+  // assume install prefix /usr
+  getFilePaths().push_back(getDriver().SysRoot + "/usr/"
+                           + getTriple().getArchName().str() + "-w64-mingw32" + "/lib");
+  getFilePaths().push_back(getDriver().SysRoot + "/usr/lib/gcc/"
+                           + getTriple().getArchName().str() + "-w64-mingw32" + "/" + GCCVersion);
+#endif
+}
+
+Tool *MinGW::buildLinker() const {
+  return new tools::MinGW::Link(*this);
+}
+
+bool MinGW::isPICDefault() const {
+  return getArch() == llvm::Triple::x86_64;
+}
+
+bool MinGW::isPICDefaultForced() 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<128> P(getDriver().ResourceDir);
+    llvm::sys::path::append(P, "include");
+    addSystemInclude(DriverArgs, CC1Args, P.str());
+  }
+
+  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
+    return;
+
+#ifdef LLVM_ON_WIN32
+  // Clang runs on Windows, assume sysroot toolchain
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../" + getTriple().getArchName().str() + "-w64-mingw32"
+                   + "/include");
+  // Add users standard include directory
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../include");
+#else
+  // Clang runs somewhere else, e.g. Linux, assume install prefix /usr
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().SysRoot + "/usr/" + getTriple().getArchName().str() + "-w64-mingw32"
+                                       + "/include");
+#endif
+}
+
+void MinGW::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs,
+                                           ArgStringList &CC1Args) const {
+  if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+      DriverArgs.hasArg(options::OPT_nostdincxx))
+    return;
+
+  // Check if libc++ has been enabled and provide its include paths if so.
+  if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) {
+    // libc++ is always installed at a fixed path on Linux currently.
+#ifdef LLVM_ON_WIN32
+    addSystemInclude(DriverArgs, CC1Args,
+                     getDriver().Dir + "/../include/c++/v1");
+#else
+    addSystemInclude(DriverArgs, CC1Args,
+                     getDriver().SysRoot + "/usr/include/c++/v1");
+#endif
+    return;
+  }
+#ifdef LLVM_ON_WIN32
+  // Assume sysroot toolchain
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../include/c++/" + GCCVersion);
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../include/c++/" + GCCVersion
+                   + "/" + getTriple().getArchName().str() + "-w64-mingw32");
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../include/c++/" + GCCVersion
+                   + "/backward");
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../" + getTriple().getArchName().str() + "-w64-mingw32"
+                   + "/include/c++");
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../" + getTriple().getArchName().str() + "-w64-mingw32"
+                   + "/include/c++/" + getTriple().getArchName().str() + "-w64-mingw32");
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../" + getTriple().getArchName().str() + "-w64-mingw32"
+                   + "/include/c++/backward");
+#else
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().SysRoot + "/usr/" + getTriple().getArchName().str() + "-w64-mingw32"
+                   + "/include/c++/" + GCCVersion);
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().SysRoot + "/usr/" + getTriple().getArchName().str() + "-w64-mingw32"
+                   + "/include/c++/" + GCCVersion
+                   + "/" + getTriple().getArchName().str() + "-w64-mingw32");
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().SysRoot + "/usr/" + getTriple().getArchName().str() + "-w64-mingw32"
+                   + "/include/c++/" + GCCVersion + "/backward");
+#endif
+}

lib/Driver/ToolChains.h

   virtual Tool *buildAssembler() const;
 };
 
+class LLVM_LIBRARY_VISIBILITY MinGW : public Generic_GCC {
+public:
+  MinGW(const Driver &D, const llvm::Triple &Triple,
+        const llvm::opt::ArgList &Args);
+
+  virtual bool isPICDefault() const;
+  virtual bool isPICDefaultForced() const;
+
+  virtual void
+  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                            llvm::opt::ArgStringList &CC1Args) const;
+  virtual void
+  AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                               llvm::opt::ArgStringList &CC1Args) const;
+
+protected:
+  virtual Tool *buildLinker() const;
+
+private:
+  std::string GCCVersion;
+};
+
 
 class LLVM_LIBRARY_VISIBILITY XCore : public ToolChain {
 public:

lib/Driver/Tools.h

   };
 } // end namespace visualstudio
 
+  /// MinGW -- Directly call GNU Binutils assembler and linker
+namespace MinGW {
+  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
+  public:
+    Link(const ToolChain &TC) : Tool("MinGW::Link", "linker", TC) {}
+
+    virtual bool hasIntegratedCPP() const { return false; }
+    virtual bool isLinkJob() const { return true; }
+
+    virtual void ConstructJob(Compilation &C, const JobAction &JA,
+                              const InputInfo &Output,
+                              const InputInfoList &Inputs,
+                              const llvm::opt::ArgList &TCArgs,
+                              const char *LinkingOutput) const;
+  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);

lib/Driver/Tools.cpp

   return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs);
 }
 
+/// MinGW Tools
+void MinGW::Link::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)) {
+    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::Link::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 windows");
+  else if (Args.hasArg(options::OPT_mconsole))
+    CmdArgs.push_back("--subsystem console");
+
+  if (Args.hasArg(options::OPT_static))
+    CmdArgs.push_back("-Bstatic");
+  else {
+    // -shared means building DLL
+    if (Args.hasArg(options::OPT_shared))
+      CmdArgs.push_back("--shared");
+    else if (Args.hasArg(options::OPT_mdll))
+      CmdArgs.push_back("--dll");
+    CmdArgs.push_back("-Bdynamic");
+    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");
+  }
+
+  AddLinkerInputs(TC, Inputs, Args, CmdArgs);
+
+  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));
+
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Output.getFilename());
+
+  //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");
+
+      // TODO: remove unconditionally linking pthreads library
+      // Currently required for OpenMP and posix-threading libgcc
+      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(new Command(JA, *this, Exec, CmdArgs));
+}
 
 /// XCore Tools
 // We pass assemble and link construction to the xcc tool.

lib/Frontend/InitHeaderSearch.cpp

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

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

   switch (os) {
   case llvm::Triple::Linux:
     llvm_unreachable("Include management is handled in the driver.");
-
+    break;
   case llvm::Triple::Haiku:
     AddPath("/boot/common/include", System, false);
     AddPath("/boot/develop/headers/os", System, false);

   case llvm::Triple::Win32:
     switch (triple.getEnvironment()) {
     default: llvm_unreachable("Include management is handled in the driver.");
+      break;
     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.str(), 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.str(), System, false);
-
-      // mingw.org crt include paths
-      // <sysroot>/include
-      P.resize(HSOpts.ResourceDir.size());
-      llvm::sys::path::append(P, "../../../include");
-      AddPath(P.str(), System, false);
-      AddPath("/mingw/include", System, false);
-#if defined(LLVM_ON_WIN32)
-      AddPath("c:/mingw/include", System, false); 
-#endif
       break;
     }
     break;

     break;
   }
 
-  if ( os != llvm::Triple::RTEMS )
+  if ( os != llvm::Triple::RTEMS && !Triple.isWindowsGNUEnvironment() )
     AddPath("/usr/include", ExternCSystem, false);
 }
 

       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;
     }
   case llvm::Triple::DragonFly: