[clang] [MinGW] Rename the 'Arch' member to 'SysrootName'. NFC.

[mstorsjo]

Summary

This string isn't a plain architecture name, but contains the whole
subdir name used for the sysroot, which often is equal to the target
triple.

[MaskRay]

How is this different from clang::driver::Driver::SysRoot?

From SysrootName + "/sys-root" looks like the sys-root directory is the sysroot? Perhaps there is a better way describing SysrootName but I cannot think of it...
SysrootName may be good enough.

[mstorsjo]

In D112387#3090707, @MaskRay wrote:

How is this different from clang::driver::Driver::SysRoot?

From SysrootName + "/sys-root" looks like the sys-root directory is the sysroot? Perhaps there is a better way describing SysrootName but I cannot think of it...
SysrootName may be good enough.

Yeah, it’s kinda vague what it is. It’s mainly a triple, except that it also can be “mingw32” or similar, in some cases. I guess it could be SubdirName too, or something related to that.

[MaskRay]

Making the word Subdir part of the variable name LG.

[mstorsjo]

Renamed the variable to SubdirName. Will push tomorrow.

clang/lib/Driver/ToolChains/MinGW.h

 
 private:
   CudaInstallationDetector CudaInstallation;
   RocmInstallationDetector RocmInstallation;
 
   std::string Base;
   std::string GccLibDir;
   std::string Ver;
-  std::string Arch;
+  std::string SysrootName;
   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

for (llvm::sys::fs::directory_iterator LI(LibDir, EC), LE; !EC && LI != LE;
     Version = CandidateVersion;
     Ver = std::string(VersionText);
     GccLibDir = LI->path();
   }
   return Ver.size();
 }
 
 void toolchains::MinGW::findGccLibDir() {
-  llvm::SmallVector<llvm::SmallString<32>, 2> Archs;
-  Archs.emplace_back(getTriple().getArchName());
-  Archs[0] += "-w64-mingw32";
-  Archs.emplace_back("mingw32");
-  if (Arch.empty())
-    Arch = std::string(Archs[0].str());
+  llvm::SmallVector<llvm::SmallString<32>, 2> SysrootNames;
+  SysrootNames.emplace_back(getTriple().getArchName());
+  SysrootNames[0] += "-w64-mingw32";
+  SysrootNames.emplace_back("mingw32");
+  if (SysrootName.empty())
+    SysrootName = std::string(SysrootNames[0].str());
   // lib: Arch Linux, Ubuntu, Windows
   // lib64: openSUSE Linux
   for (StringRef CandidateLib : {"lib", "lib64"}) {
-    for (StringRef CandidateArch : Archs) {
+    for (StringRef CandidateSysroot : SysrootNames) {
       llvm::SmallString<1024> LibDir(Base);
-      llvm::sys::path::append(LibDir, CandidateLib, "gcc", CandidateArch);
+      llvm::sys::path::append(LibDir, CandidateLib, "gcc", CandidateSysroot);
       if (findGccVersion(LibDir, GccLibDir, Ver)) {
-        Arch = std::string(CandidateArch);
+        SysrootName = std::string(CandidateSysroot);
         return;
       }
     }
   }
 }
 
 llvm::ErrorOr<std::string> toolchains::MinGW::findGcc() {
   llvm::SmallVector<llvm::SmallString<32>, 2> Gccs;
llvm::ErrorOr<std::string> toolchains::MinGW::findClangRelativeSysroot() {
   Subdirs.emplace_back(getTriple().str());
   Subdirs.emplace_back(getTriple().getArchName());
   Subdirs[1] += "-w64-mingw32";
   StringRef ClangRoot =
       llvm::sys::path::parent_path(getDriver().getInstalledDir());
   StringRef Sep = llvm::sys::path::get_separator();
   for (StringRef CandidateSubdir : Subdirs) {
     if (llvm::sys::fs::is_directory(ClangRoot + Sep + CandidateSubdir)) {
-      Arch = std::string(CandidateSubdir);
+      SysrootName = std::string(CandidateSubdir);
       return (ClangRoot + Sep + CandidateSubdir).str();
     }
   }
   return make_error_code(std::errc::no_such_file_or_directory);
 }
 
 toolchains::MinGW::MinGW(const Driver &D, const llvm::Triple &Triple,
                          const ArgList &Args)
Base = std::string(
         llvm::sys::path::parent_path(getDriver().getInstalledDir()));
 
   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());
+      (Base + SysrootName + llvm::sys::path::get_separator() + "lib").str());
   getFilePaths().push_back(Base + "lib");
   // openSUSE
-  getFilePaths().push_back(Base + Arch + "/sys-root/mingw/lib");
+  getFilePaths().push_back(Base + SysrootName + "/sys-root/mingw/lib");
 
   NativeLLVMSupport =
       Args.getLastArgValue(options::OPT_fuse_ld_EQ, CLANG_DEFAULT_LINKER)
           .equals_insensitive("lld");
 }
 
 bool toolchains::MinGW::IsIntegratedAssemblerDefault() const { return true; }
 
void toolchains::MinGW::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
   }
 
   if (DriverArgs.hasArg(options::OPT_nostdlibinc))
     return;
 
   if (GetRuntimeLibType(DriverArgs) == ToolChain::RLT_Libgcc) {
     // openSUSE
     addSystemInclude(DriverArgs, CC1Args,
-                     Base + Arch + "/sys-root/mingw/include");
+                     Base + SysrootName + "/sys-root/mingw/include");
   }
 
   addSystemInclude(DriverArgs, CC1Args,
-                   Base + Arch + llvm::sys::path::get_separator() + "include");
+                   Base + SysrootName + llvm::sys::path::get_separator() +
+                       "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: {
     std::string TargetDir = (Base + "include" + Slash + getTripleString() +
                              Slash + "c++" + Slash + "v1")
                                 .str();
     if (getDriver().getVFS().exists(TargetDir))
       addSystemInclude(DriverArgs, CC1Args, TargetDir);
-    addSystemInclude(DriverArgs, CC1Args, Base + Arch + Slash + "include" +
-                                              Slash + "c++" + Slash + "v1");
+    addSystemInclude(DriverArgs, CC1Args,
+                     Base + SysrootName + 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;
     CppIncludeBases.emplace_back(Base);
-    llvm::sys::path::append(CppIncludeBases[0], Arch, "include", "c++");
+    llvm::sys::path::append(CppIncludeBases[0], SysrootName, "include", "c++");
     CppIncludeBases.emplace_back(Base);
-    llvm::sys::path::append(CppIncludeBases[1], Arch, "include", "c++", Ver);
+    llvm::sys::path::append(CppIncludeBases[1], SysrootName, "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++");
     for (auto &CppIncludeBase : CppIncludeBases) {
       addSystemInclude(DriverArgs, CC1Args, CppIncludeBase);
       CppIncludeBase += Slash;
-      addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + Arch);
+      addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + SysrootName);
       addSystemInclude(DriverArgs, CC1Args, CppIncludeBase + "backward");
     }
     break;
   }
 }