[clang] [MinGW] Fix paths on Gentoo

[maharmstone]

Summary

There's code in clang/lib/Driver/ToolChains/Gnu.cpp for Clang to use Gentoo's include and lib paths, but this is missing for mingw, meaning that any C++ programs using the STL will fail to compile.

See https://bugs.gentoo.org/788430

[mstorsjo]

(I’ll have a look and comment on the patch later.)

[mstorsjo]

The change looks ok to me, but I think it'd be good to have a testcase for finding these paths (IIRC there are a bunch of simulated sysroots under clang/test/Driver).

[mgorny]

In D111081#3043831, @mstorsjo wrote:

The change looks ok to me, but I think it'd be good to have a testcase for finding these paths (IIRC there are a bunch of simulated sysroots under clang/test/Driver).

Seconded. There are already some Gentoo trees there, so it shouldn't be hard to add one more.

[maharmstone]

Added tests

[maharmstone]

I can't see that any of the lib paths are tested at all, though I may be missing something.

[mstorsjo]

Looks ok to me - WDYT @mgorny?

[mgorny]

Well, I dunno how MinGW works, so can't judge that part. Furthermore, I'm thoroughly confused why this works on top of existing (non-Gentoo?) test tree. Could you explain it a bit more?

[mstorsjo]

In D111081#3212890, @mgorny wrote:

Well, I dunno how MinGW works, so can't judge that part. Furthermore, I'm thoroughly confused why this works on top of existing (non-Gentoo?) test tree. Could you explain it a bit more?

It looks like the clang driver just blindly adds these directories to the list of include paths, regardless of whether they exist or not. So with the current test, they don't need to exist (but maybe it would be good to create such empty directories to make the test a bit more correct, in case the driver is modified to not add nonexistent directories blindly).

FYI @maharmstone the test needs to be rebased to fit on top of current git, after rG897c86dec5af2780d443edd852aa5911e2650ec6.

[maharmstone]

Rebased patch against current upstream

[MaskRay]

Does Gentoo patch upstream to do something different? (.../g++-v10/...) Well, I wish that Gentoo does not do this.
This adds complexity to Clang which in practice tries to provide some drop-in replacement ability.

[maharmstone]

In D111081#3627852, @MaskRay wrote:

Does Gentoo patch upstream to do something different? (.../g++-v10/...) Well, I wish that Gentoo does not do this.
This adds complexity to Clang which in practice tries to provide some drop-in replacement ability.

Clang doesn't work at all on Gentoo at the moment with any of the mingw targets, hence this patch.

As I said in the top comment, these changes are mirroring what's in clang/lib/Driver/ToolChains/Gnu.cpp for the Linux triplets.

[mstorsjo]

LGTM, thanks, and sorry for losing track of it earlier.

Do you need someone to push the patch for you? In that case, can you provide your preferred git author line for the patch?

[maharmstone]

In D111081#3633908, @mstorsjo wrote:

LGTM, thanks, and sorry for losing track of it earlier.

Do you need someone to push the patch for you? In that case, can you provide your preferred git author line for the patch?

Thanks Martin. Yes please - "Mark Harmstone <[e-mail]>"

clang/lib/Driver/ToolChains/MinGW.h

protected:
   Tool *buildAssembler() const override;
 
 private:
   CudaInstallationDetector CudaInstallation;
   RocmInstallationDetector RocmInstallation;
 
   std::string Base;
   std::string GccLibDir;
+  clang::driver::toolchains::Generic_GCC::GCCVersion GccVer;
   std::string Ver;
   std::string Arch;
   mutable std::unique_ptr<tools::gcc::Preprocessor> Preprocessor;
   mutable std::unique_ptr<tools::gcc::Compiler> Compiler;
   void findGccLibDir();
   llvm::ErrorOr<std::string> findGcc();
   llvm::ErrorOr<std::string> findClangRelativeSysroot();
 
   bool NativeLLVMSupport;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_MINGW_H

clang/lib/Driver/ToolChains/MinGW.cpp

void tools::MinGW::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   const char *Exec = Args.MakeArgString(TC.GetLinkerPath());
   C.addCommand(std::make_unique<Command>(JA, *this,
                                          ResponseFileSupport::AtFileUTF8(),
                                          Exec, CmdArgs, Inputs, Output));
 }
 
 // Simplified from Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple.
 static bool findGccVersion(StringRef LibDir, std::string &GccLibDir,
-                           std::string &Ver) {
-  auto Version = toolchains::Generic_GCC::GCCVersion::Parse("0.0.0");
+                           std::string &Ver,
+                           toolchains::Generic_GCC::GCCVersion &Version) {
+  Version = toolchains::Generic_GCC::GCCVersion::Parse("0.0.0");
   std::error_code EC;
   for (llvm::sys::fs::directory_iterator LI(LibDir, EC), LE; !EC && LI != LE;
        LI = LI.increment(EC)) {
     StringRef VersionText = llvm::sys::path::filename(LI->path());
     auto CandidateVersion =
         toolchains::Generic_GCC::GCCVersion::Parse(VersionText);
     if (CandidateVersion.Major == -1)
       continue;
void toolchains::MinGW::findGccLibDir() {
   if (Arch.empty())
     Arch = std::string(Archs[0].str());
   // lib: Arch Linux, Ubuntu, Windows
   // lib64: openSUSE Linux
   for (StringRef CandidateLib : {"lib", "lib64"}) {
     for (StringRef CandidateArch : Archs) {
       llvm::SmallString<1024> LibDir(Base);
       llvm::sys::path::append(LibDir, CandidateLib, "gcc", CandidateArch);
-      if (findGccVersion(LibDir, GccLibDir, Ver)) {
+      if (findGccVersion(LibDir, GccLibDir, Ver, GccVer)) {
         Arch = std::string(CandidateArch);
         return;
       }
     }
   }
 }
 
 llvm::ErrorOr<std::string> toolchains::MinGW::findGcc() {
toolchains::MinGW::MinGW(const Driver &D, const llvm::Triple &Triple,
 
   Base += llvm::sys::path::get_separator();
   findGccLibDir();
   // GccLibDir must precede Base/lib so that the
   // correct crtbegin.o ,cetend.o would be found.
   getFilePaths().push_back(GccLibDir);
   getFilePaths().push_back(
       (Base + Arch + llvm::sys::path::get_separator() + "lib").str());
+
+  // Gentoo
+  getFilePaths().push_back(
+      (Base + Arch + llvm::sys::path::get_separator() + "mingw/lib").str());
+
   getFilePaths().push_back(Base + "lib");
   // openSUSE
   getFilePaths().push_back(Base + Arch + "/sys-root/mingw/lib");
 
   NativeLLVMSupport =
       Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)
           .equals_insensitive("lld");
 }
void toolchains::MinGW::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
   if (GetRuntimeLibType(DriverArgs) == ToolChain::RLT_Libgcc) {
     // openSUSE
     addSystemInclude(DriverArgs, CC1Args,
                      Base + Arch + "/sys-root/mingw/include");
   }
 
   addSystemInclude(DriverArgs, CC1Args,
                    Base + Arch + llvm::sys::path::get_separator() + "include");
+
+  // Gentoo
+  addSystemInclude(DriverArgs, CC1Args,
+                   Base + Arch + llvm::sys::path::get_separator() + "usr/include");
+
   addSystemInclude(DriverArgs, CC1Args, Base + "include");
 }
 
 void toolchains::MinGW::AddClangCXXStdlibIncludeArgs(
     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
       DriverArgs.hasArg(options::OPT_nostdincxx))
     return;
 
   StringRef Slash = llvm::sys::path::get_separator();
 
   switch (GetCXXStdlibType(DriverArgs)) {
   case ToolChain::CST_Libcxx:
     addSystemInclude(DriverArgs, CC1Args, Base + Arch + Slash + "include" +
                                               Slash + "c++" + Slash + "v1");
     addSystemInclude(DriverArgs, CC1Args,
                      Base + "include" + Slash + "c++" + Slash + "v1");
     break;
 
   case ToolChain::CST_Libstdcxx:
-    llvm::SmallVector<llvm::SmallString<1024>, 4> CppIncludeBases;
+    llvm::SmallVector<llvm::SmallString<1024>, 7> CppIncludeBases;
     CppIncludeBases.emplace_back(Base);
     llvm::sys::path::append(CppIncludeBases[0], Arch, "include", "c++");
     CppIncludeBases.emplace_back(Base);
     llvm::sys::path::append(CppIncludeBases[1], Arch, "include", "c++", Ver);
     CppIncludeBases.emplace_back(Base);
     llvm::sys::path::append(CppIncludeBases[2], "include", "c++", Ver);
     CppIncludeBases.emplace_back(GccLibDir);
     llvm::sys::path::append(CppIncludeBases[3], "include", "c++");
+    CppIncludeBases.emplace_back(GccLibDir);
+    llvm::sys::path::append(CppIncludeBases[4], "include",
+                            "g++-v" + GccVer.Text);
+    CppIncludeBases.emplace_back(GccLibDir);
+    llvm::sys::path::append(CppIncludeBases[5], "include",
+                            "g++-v" + GccVer.MajorStr + "." + GccVer.MinorStr);
+    CppIncludeBases.emplace_back(GccLibDir);
+    llvm::sys::path::append(CppIncludeBases[6], "include",
+                            "g++-v" + GccVer.MajorStr);
     for (auto &CppIncludeBase : CppIncludeBases) {
       addSystemInclude(DriverArgs, CC1Args, CppIncludeBase);
       CppIncludeBase += Slash;
       addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + Arch);
       addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + "backward");
     }
     break;
   }
 }