MinGW toolchain

[yaron.keren]

Summary

Patch by Martell Malone based on work done by ruben vb.

I have created a patch for clang that will find the include directories for the new windows-gnu triplet.

[majnemer]

lib/Driver/MinGWToolChain.cpp

33

This todo is pretty vague, can you add more context?

48

Need a space before the start of the comment.

[yaron.keren]

Chandler, I''ve contacted Ruben to contribute as well.

David, I think Martell means that the driver needs to locate gcc and from this to find libstdc++ location.

Martell, on previous e-mail discussion on the lists it was suggested that the best way to do this is by locating gcc.exe on the PATH. This way, you could have several MinGW versions installed on the system, possibly in non standard locations and the correct one would be chosen. Correct one means the gcc you'd get if you run gcc from the command prompt. This also avoids hardcoded paths as today.

About the directories, it's worth supporting both MinGW-w64 and MinGW.org. Although personally I use and prefer the -w64 distribution we can't ignore MinGW.org is quite popular as well.

Running g++ -E -x c++ - -v < nul you can get the include directories.
Here is the directories I found for both distributions:

mingw.org

gcc location
BASEPATH\bin\gcc.exe

C32 includes
BASEPATH\lib\gcc\mingw32\X.Y.Z\include
BASEPATH\lib\gcc\mingw32\X.Y.Z\include-fixed
BASEPATH\include

C++32 includes
BASEPATH\lib\gcc\mingw32\X.Y.Z\include\c++
BASEPATH\lib\gcc\mingw32\X.Y.Z\include\c++\mingw32
BASEPATH\lib\gcc\mingw32\X.Y.Z\include\c++\backward

mingw-w64

gcc includes
BASEPATH\bin\gcc.exe

C32 includes
BASEPATH\lib\gcc\i686-w64-mingw32\X.Y.Z\include
BASEPATH\lib\gcc\i686-w64-mingw32\X.Y.Z\include-fixed
BASEPATH\i686-w64-mingw32\include

C64 includes
BASEPATH\lib\gcc\x86_64-w64-mingw32\X.Y.Z\include
BASEPATH\lib\gcc\x86_64-w64-mingw32\X.Y.Z\include-fixed
BASEPATH\x86_64-w64-mingw32\include

C++32 includes
BASEPATH\i686-w64-mingw32\include\c++

C++64 includes
BASEPATH\x86_64-w64-mingw32\include\c++

I'm not sure the distribution could be reliably identified. If yes, we could add the distribution-specific includes. If not, we could add all include directories for both distributions and clang will prune the nonexisting ones. Note this will not work well if you have both disribtuions installed since all includes will be added.

[rubenvb]

Hi!

I'm the original author of the patch, and hereby I officially contribute the code contained in this commit :-).

I understand the missing MinGW.org support code, this needs to be fixed, although IMHO that would classify as legacy support, as MinGW.org has been abandoned by all major Linux distro's, there is no support for 64-bit, nor any support for much of the newer Windows and DirectX APIs. But that is irrelevant to the discussion here.

The reason I chose for hardcoded paths is twofold:

1. inheriting from Generic_GCC was impossible because this would break or at least do evil things for the Linux cross-compilers. The current solution "hardcodes" the standard paths, which means (apart from GCC version detection) the standard install directories everywhere (official Windows binaries, major Linux distribution cross-compilers such as Arch, Debian, Ubuntu.
2. This makes Clang more GCC independent, which is the final goal (remove all dependencies on GCC) and will allow MinGW-w64 Clang to be a standalone solution.

The second point is far off future, as the GCC runtime libraries (and some startup code) are still linked at this point. This patch does away with any GCC executable dependencies, though.

[yaron.keren]

Thanks Ruben!

By hardcoded paths I did not mean what's in the patch above which are relative-to-gcc-hardcoded, that's OK.
I meant what's in clang trunk, absolute-hardcoded paths and versions such as c:\mingw which assumes install location.

I fully agree with you regarding mingw.org vs -w64. If supporting mingw.org required more work than adding the several include paths I listed above I'd hesitate, but if it's trivial to support than why not. BTW, LLVM does have a mingw.org building bot.

[martell]

Okay so I have looked at all the comments and I'm trying to get all the pieces together to get this working best as possible.

@rubenvb I first would like to thank you for allowing this patch to be included, :)

With you being the original author I'd like to poke your brain about a thing or two.
We could have two c++ libraries (libstdc++ or libc++)
Based on which on is going to be used we will have todo the includes accordingly.
Can I get your thoughts on this, should I implement this in the driver or should we always assume libstdc++?

@yaron.kernen I have made a few inline comments with reference to the different questions posed.

lib/Driver/MinGWToolChain.cpp

33

@majnemer this comment comes from the original patch from @rubenvb
I will add a space and clarify exactly what is meant here.

As @yaron.keren has said we should be finding libstdc++ from the gcc location.

48

Will fix this in the updated diff. Thank you

lib/Frontend/InitHeaderSearch.cpp

307–308

This isn't exactly the best looking code.
It gets the job done but I would prefer to have a better implementation of disabling that include.
Suggestions would be much appreciated

415–423

As @rubenvb said I think we should really look at mingw.org as legacy.
The simplest way to have support for it would be to leave these lines in the code intact.

That way we could focus on a mingw64 driver while still keeping mingw.org's currently supported state.

I can do another PR at a later stage to add mingw.org support to the driver.
After we have solved some other issues with it.
I.E I think it would be best to split the work load here.

[rubenvb]

@martell: Currently there is no functional libc++, so it makes little sense in coding up directory logic if that might still change between then and now. But if you feel you can write something future-proof in this regard, I won't stop you.

lib/Frontend/InitHeaderSearch.cpp

307–308

This was not part of my original patch. Are you sure it is necessary? Take a look at my additional changes in InitHeaderSearch.cpp (the last change in the file). I never had /usr/include appear when I tested my original patch for any configuration.

(for reference, my patch is located here: http://llvm.org/bugs/show_bug.cgi?id=18546)

[compnerd]

lib/Driver/MinGWToolChain.cpp

37

Please use LLVM_ON_WIN32 rather than the raw _WIN32 macro.

41

Im not sure I understand this piece of the code.

It seems that you use the location of the driver and then move up to find the compiler library directory on Windows, but on Linux you use a sysroot relative path.

I am confused on the behaviour here since nothing prevents the use of --sysroot on Windows, so why not honour that always? Uniformity in behaviour is probably a good thing here.

I was thinking something like this:

const Driver &D = getDriver();
const llvm::Triple &T = getTriple();
Twine GCCLibDir = (D.SysRoot ? D.SysRoot + Twine("/usr")
                             : llvm::sys::path::parent_path(D.Dir));
GCCLibDir = GCCLibDir + "/lib/gcc" + T.getArchName() + "-w64-mingw32";

51

Similar to above, you could honour the sysroot parameter as well and default to the sibling library directory to the location of the driver.

110

Again here and in the next function.

lib/Driver/Tools.cpp

7100

Maybe add an assertion that only these architectures are ever received? The curly braces are unnecessary.

7112

We have switched over to C++11, this might be clearer as:

for (const auto &I : Inputs)
  CmdArgs.push_back(I.getFilename());

7130

Why not just add a TODO comment and remove this line?

7152

An assertion that only these two architectures ever reach here would be nice.

7163

I may be mistaken here, but I believe you have the entry points swapped.

7179

Is the indentation here off?

7188

C++11 could make this nicer:

for (const auto &P : Paths)
  CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + P));

7194

Space after the //.

7214

Hmm...perhaps add a switch for the openmp framework and handle that (now that there is also the Intel OpenMP implementation.

7219

Space before the TODO.

lib/Driver/Tools.h

621

You probably want to change the dragonfly name here :-)

634

Here as well.

lib/Frontend/InitHeaderSearch.cpp

308

This can be simplified a bit as:

if (os != llvm::Triple::RTEMS && !Triple.isWindowsGNUEnvironment())

[martell]

Okay so I'll start updating the patch to suit all those changes.
How do I update the patch on phabricator?

lib/Driver/Tools.h

621

What name should I change it to?

[yaron.keren]

Martell, To submit an updated patch:

• Click *Differential*.
• Click *Create Revision*.
• Paste the updated diff.
• Select the review you want to from the *Attach To* dropdown and click *Continue*.
• Click *Save*.

I marked the revision as editable by all users so I hope this will work. If you don't see D3240 in the attach to list then it's possible that only the author can submit the new diff. I didn't find answer to this on
https://secure.phabricator.com/book/phabricator/
nor do I see a way to add or change author.

In this case, either open a new revision and link to this one and I'll close it or email me the diff and I'll submit it.

[yaron.keren]

Martell, I found the command to take the revision. It's called "Commandeer revision" in the Action pull-down box. I didn't see it before because I'm already the revision owner and can't take over the revision...

So, please Commandeer this revision and then you can follow the instructions in previous comment.

[johanengelen]

lib/Driver/MinGWToolChain.cpp

137

To find the correct include paths with Mingw-build packages, "GCCVersion" has to be stripped from the paths and they need to be prepended with x86_64-w64-mingw32.
Here the code that makes it work:

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

[yaron.keren]

See also http://reviews.llvm.org/D4177

[rnk]

I seem to recall that you guys didn't want to use --sysroot to point to the mingw installation. The Generic_GCC toolchain respects a --gcc-toolchain= flag which could be used to select a mingw installation instead.

[• rafael]

What is the status on this? It would be really nice to drop the hardcoded paths.

[Alexpux]

Guys, I'm improve this patch basing on GCC specs:
https://github.com/Alexpux/MINGW-packages/blob/master/mingw-w64-clang/clang-mingw-driver.patch

It works in general but need to test.

[yaron.keren]

Sure, feel free to comandeer the revision or create a new one.

2014-09-09 16:25 GMT+03:00 Alexey Pavlov <[e-mail]>:

Guys, I'm improve this patch basing on GCC specs:

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

It works in general but need to test.

http://reviews.llvm.org/D3420

[Alexpux]

Create new on
http://reviews.llvm.org/D5268

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)
+  : ToolChain(D, Triple, Args) {
+  //TODO: libc++ directory
+
+  // Get GCC version string for library and header directories
+  const std::string GCClibdir =
+#ifdef _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
+    llvm::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 _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::IsIntegratedAssemblerDefault() const {
+  return true;
+}
+
+Tool *MinGW::buildAssembler() const {
+  return new tools::MinGW::Assemble(*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;
+}
+
+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 _WIN32
+  // Clang runs on Windows, assume sysroot toolchain
+  addSystemInclude(DriverArgs, CC1Args,
+                   getDriver().Dir + "/../" + getTriple().getArchName().str() + "-w64-mingw32"
+                   + "/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.
+    addSystemInclude(DriverArgs, CC1Args,
+                     getDriver().SysRoot + "/usr/include/c++/v1");
+    return;
+  }
+#ifdef _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");
+#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 ToolChain {
+public:
+  MinGW(const Driver &D, const llvm::Triple &Triple,
+        const llvm::opt::ArgList &Args);
+
+  virtual bool IsIntegratedAssemblerDefault() const;
+  virtual bool IsUnwindTablesDefault() const;
+  virtual bool isPICDefault() const;
+  virtual bool isPIEDefault() 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;
+  virtual Tool *buildAssembler() 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 Assemble : public Tool  {
+  public:
+    Assemble(const ToolChain &TC) : Tool("dragonfly::Assemble", "assembler",
+                                         TC) {}
+
+    virtual bool hasIntegratedCPP() const { return false; }
+
+    virtual void ConstructJob(Compilation &C, const JobAction &JA,
+                              const InputInfo &Output,
+                              const InputInfoList &Inputs,
+                              const llvm::opt::ArgList &TCArgs,
+                              const char *LinkingOutput) const;
+  };
+  class LLVM_LIBRARY_VISIBILITY Link : public Tool  {
+  public:
+    Link(const ToolChain &TC) : Tool("dragonfly::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;
+  };
+} // 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::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
+                                   const InputInfo &Output,
+                                   const InputInfoList &Inputs,
+                                   const ArgList &Args,
+                                   const char *LinkingOutput) const {
+  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 (InputInfoList::const_iterator
+         it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
+    const InputInfo &II = *it;
+    CmdArgs.push_back(II.getFilename());
+  }
+
+  const char *Exec =
+    Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  C.addCommand(new Command(JA, *this, Exec, CmdArgs));
+}
+
+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_static))
+    CmdArgs.push_back("-Bstatic");
+  else {
+    CmdArgs.push_back("-Bdynamic");
+    // -shared means building DLL
+    if (Args.hasArg(options::OPT_shared)) {
+      CmdArgs.push_back("--shared");
+      CmdArgs.push_back("-Bdynamic");
+      if (TC.getArch() == llvm::Triple::x86)
+        CmdArgs.push_back("-e DllMainCRTStartup");
+      else
+        CmdArgs.push_back("-e _DllMainCRTStartup@12");
+
+      CmdArgs.push_back("--enable-auto-image-base");
+    }
+  }
+
+  CmdArgs.push_back("-o");
+  CmdArgs.push_back(Output.getFilename());
+
+  if (!Args.hasArg(options::OPT_nostdlib) &&
+      !Args.hasArg(options::OPT_nostartfiles)) {
+    if (Args.hasArg(options::OPT_shared))
+      CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("dllcrt2.o")));
+    else {
+    CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crt2.o")));
+    CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtbegin.o")));
+    }
+  }
+
+  Args.AddAllArgs(CmdArgs, options::OPT_L);
+
+  const ToolChain::path_list Paths = TC.getFilePaths();
+
+  for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end();
+       i != e; ++i)
+    CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i));
+
+  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)) {
+      CmdArgs.push_back("--start-group");
+
+      if (Args.hasArg(options::OPT_fopenmp))
+        CmdArgs.push_back("-lgomp");
+
+      AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
+
+      //TODO: remove unconditionally linking pthreads library
+      // Currently required for OpenMP and posix-threading libgcc
+      CmdArgs.push_back("-lpthread");
+
+      // add system libraries
+      // TODO: handle msvcr*.dll versions here.
+      CmdArgs.push_back("-lmingw32");
+      CmdArgs.push_back("-lmoldname");
+      CmdArgs.push_back("-lmingwex");
+      CmdArgs.push_back("-lmsvcrt");
+      CmdArgs.push_back("-ladvapi32");
+      CmdArgs.push_back("-lshell32");
+      CmdArgs.push_back("-luser32");
+      CmdArgs.push_back("-lkernel32");
+
+      CmdArgs.push_back("--end-group");
+      AddLibgcc(TC.getTriple(), D, CmdArgs, Args);
+    }
+
+    if (!Args.hasArg(options::OPT_nostartfiles)) {
+      // Add crtfastmath.o if available and fast math is enabled.
+      getToolChain().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) &&
+     (!((os == llvm::Triple::Win32) && (triple.getEnvironment() == llvm::Triple::GNU))))
     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: