[clang][Driver][CUDA] Get rid of unused LibPath

[kadircet]

Summary

LibPath discovered during InstallationDetection wasn't used anywhere.
Moreover it actually resulted in discarding installations that don't have any
/lib directory.

This is causing troubles for our pipelines downstream, that want to perform
syntax-only analysis on the sources.

[tra]

Given that it's indeed unused, I'm fine with removing it.

That said, it's somewhat odd that in your setup clang was able to find everything but the library directory. You generally would need to have --cuda-path= among compiler options and that should be pointing to a valid CUDA installation.

Can you elaborate on where/how clang manages to find CUDA headers in your case?

[kadircet]

In D141467#4045190, @tra wrote:

Given that it's indeed unused, I'm fine with removing it.

That said, it's somewhat odd that in your setup clang was able to find everything but the library directory. You generally would need to have --cuda-path= among compiler options and that should be pointing to a valid CUDA installation.

Can you elaborate on where/how clang manages to find CUDA headers in your case?

We actually use a pipeline that runs compilations by recording & replaying past snapshots of our codebase. The record logic we have don't retain access to directories in its required inputs set, as clang stats lots of directories when performing include search etc, which are not ~never needed for the compilation (apart from the one that contains the actual files).

clang/lib/Driver/ToolChains/Cuda.h

 /// A class to find a viable CUDA installation
 class CudaInstallationDetector {
 private:
   const Driver &D;
   bool IsValid = false;
   CudaVersion Version = CudaVersion::UNKNOWN;
   std::string InstallPath;
   std::string BinPath;
-  std::string LibPath;
   std::string LibDevicePath;
   std::string IncludePath;
   llvm::StringMap<std::string> LibDeviceMap;
 
   // CUDA architectures for which we have raised an error in
   // CheckCudaVersionSupportsArch.
   mutable std::bitset<(int)CudaArch::LAST> ArchsWithBadVersion;
 
return Version == CudaVersion::NEW ? CudaVersion::PARTIALLY_SUPPORTED
                                        : Version;
   }
   /// Get the detected Cuda installation path.
   StringRef getInstallPath() const { return InstallPath; }
   /// Get the detected path to Cuda's bin directory.
   StringRef getBinPath() const { return BinPath; }
   /// Get the detected Cuda Include path.
   StringRef getIncludePath() const { return IncludePath; }
-  /// Get the detected Cuda library path.
-  StringRef getLibPath() const { return LibPath; }
   /// Get the detected Cuda device library path.
   StringRef getLibDevicePath() const { return LibDevicePath; }
   /// Get libdevice file for given architecture
   std::string getLibDeviceFile(StringRef Gpu) const {
     return LibDeviceMap.lookup(Gpu);
   }
   void WarnIfUnsupportedVersion();
 };

clang/lib/Driver/ToolChains/Cuda.cpp

for (const auto &Candidate : Candidates) {
     LibDevicePath = InstallPath + "/nvvm/libdevice";
 
     if (!(FS.exists(IncludePath) && FS.exists(BinPath)))
       continue;
     bool CheckLibDevice = (!NoCudaLib || Candidate.StrictChecking);
     if (CheckLibDevice && !FS.exists(LibDevicePath))
       continue;
 
-    // On Linux, we have both lib and lib64 directories, and we need to choose
-    // based on our triple.  On MacOS, we have only a lib directory.
-    //
-    // It's sufficient for our purposes to be flexible: If both lib and lib64
-    // exist, we choose whichever one matches our triple.  Otherwise, if only
-    // lib exists, we use it.
-    if (HostTriple.isArch64Bit() && FS.exists(InstallPath + "/lib64"))
-      LibPath = InstallPath + "/lib64";
-    else if (FS.exists(InstallPath + "/lib"))
-      LibPath = InstallPath + "/lib";
-    else
-      continue;
-
     Version = CudaVersion::UNKNOWN;
     if (auto CudaHFile = FS.getBufferForFile(InstallPath + "/include/cuda.h"))
       Version = parseCudaHFile((*CudaHFile)->getBuffer());
     // As the last resort, make an educated guess between CUDA-7.0, which had
     // old-style libdevice bitcode, and an unknown recent CUDA version.
     if (Version == CudaVersion::UNKNOWN) {
       Version = FS.exists(LibDevicePath + "/libdevice.10.bc")
                     ? CudaVersion::NEW