[CUDA,HIP] Use VFS for SDK detection.

[tra]

Summary

It's useful for using clang from tools that may need need to provide SDK files
from non-standard locations.

Clang CLI only provides -ivfsoverlay for include files, but not for the driver's use in general, so there's no
good way to test this yet.

[tra]

Replaced another use of D.getVFS.

clang/lib/Driver/ToolChains/AMDGPU.cpp

 using namespace llvm::opt;
 
 void RocmInstallationDetector::scanLibDevicePath() {
   assert(!LibDevicePath.empty());
 
   const StringRef Suffix(".bc");
 
   std::error_code EC;
-  for (llvm::sys::fs::directory_iterator LI(LibDevicePath, EC), LE;
+  for (llvm::vfs::directory_iterator
+           LI = D.getVFS().dir_begin(LibDevicePath, EC),
+           LE;
        !EC && LI != LE; LI = LI.increment(EC)) {
     StringRef FilePath = LI->path();
     StringRef FileName = llvm::sys::path::filename(FilePath);
     if (!FileName.endswith(Suffix))
       continue;
 
     StringRef BaseName = FileName.drop_back(Suffix.size());
 
RocmInstallationDetector::RocmInstallationDetector(
 
   if (Args.hasArg(clang::driver::options::OPT_hip_device_lib_path_EQ)) {
     LibDevicePath
       = Args.getLastArgValue(clang::driver::options::OPT_hip_device_lib_path_EQ);
   } else if (const char *LibPathEnv = ::getenv("HIP_DEVICE_LIB_PATH")) {
     LibDevicePath = LibPathEnv;
   }
 
+  auto &FS = D.getVFS();
   if (!LibDevicePath.empty()) {
     // Maintain compatability with HIP flag/envvar pointing directly at the
     // bitcode library directory. This points directly at the library path instead
     // of the rocm root installation.
-    if (!D.getVFS().exists(LibDevicePath))
+    if (!FS.exists(LibDevicePath))
       return;
 
     scanLibDevicePath();
     IsValid = allGenericLibsValid() && !LibDeviceMap.empty();
     return;
   }
 
   for (const auto &Candidate : Candidates) {
     InstallPath = Candidate.Path;
-    if (InstallPath.empty() || !D.getVFS().exists(InstallPath))
+    if (InstallPath.empty() || !FS.exists(InstallPath))
       continue;
 
     // The install path situation in old versions of ROCm is a real mess, and
     // use a different install layout. Multiple copies of the device libraries
     // exist for each frontend project, and differ depending on which build
     // system produced the packages. Standalone OpenCL builds also have a
     // different directory structure from the ROCm OpenCL package.
     //
     // The desired structure is (${ROCM_ROOT} or
     // ${OPENCL_ROOT})/amdgcn/bitcode/*, so try to detect this layout.
 
     // BinPath = InstallPath + "/bin";
     llvm::sys::path::append(IncludePath, InstallPath, "include");
     llvm::sys::path::append(LibDevicePath, InstallPath, "amdgcn", "bitcode");
 
-    auto &FS = D.getVFS();
-
     // We don't need the include path for OpenCL, since clang already ships with
     // the default header.
 
     bool CheckLibDevice = (!NoBuiltinLibs || Candidate.StrictChecking);
     if (CheckLibDevice && !FS.exists(LibDevicePath))
       continue;
 
     scanLibDevicePath();

clang/lib/Driver/ToolChains/Cuda.cpp

struct Candidate {
 
     Candidate(std::string Path, bool StrictChecking = false)
         : Path(Path), StrictChecking(StrictChecking) {}
   };
   SmallVector<Candidate, 4> Candidates;
 
   // In decreasing order so we prefer newer versions to older versions.
   std::initializer_list<const char *> Versions = {"8.0", "7.5", "7.0"};
+  auto &FS = D.getVFS();
 
   if (Args.hasArg(clang::driver::options::OPT_cuda_path_EQ)) {
     Candidates.emplace_back(
         Args.getLastArgValue(clang::driver::options::OPT_cuda_path_EQ).str());
   } else if (HostTriple.isOSWindows()) {
     for (const char *Ver : Versions)
       Candidates.emplace_back(
           D.SysRoot + "/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v" +
if (!Args.hasArg(clang::driver::options::OPT_cuda_path_ignore_env)) {
               /*StrictChecking=*/true);
       }
     }
 
     Candidates.emplace_back(D.SysRoot + "/usr/local/cuda");
     for (const char *Ver : Versions)
       Candidates.emplace_back(D.SysRoot + "/usr/local/cuda-" + Ver);
 
-    Distro Dist(D.getVFS(), llvm::Triple(llvm::sys::getProcessTriple()));
+    Distro Dist(FS, llvm::Triple(llvm::sys::getProcessTriple()));
     if (Dist.IsDebian() || Dist.IsUbuntu())
       // Special case for Debian to have nvidia-cuda-toolkit work
       // out of the box. More info on http://bugs.debian.org/882505
       Candidates.emplace_back(D.SysRoot + "/usr/lib/cuda");
   }
 
   bool NoCudaLib = Args.hasArg(options::OPT_nogpulib);
 
   for (const auto &Candidate : Candidates) {
     InstallPath = Candidate.Path;
-    if (InstallPath.empty() || !D.getVFS().exists(InstallPath))
+    if (InstallPath.empty() || !FS.exists(InstallPath))
       continue;
 
     BinPath = InstallPath + "/bin";
     IncludePath = InstallPath + "/include";
     LibDevicePath = InstallPath + "/nvvm/libdevice";
 
-    auto &FS = D.getVFS();
     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.
if (Version >= CudaVersion::CUDA_90) {
           if (!IsNVIDIAGpuArch(GpuArch))
             continue;
           std::string GpuArchName(CudaArchToString(GpuArch));
           LibDeviceMap[GpuArchName] = FilePath;
         }
       }
     } else {
       std::error_code EC;
-      for (llvm::sys::fs::directory_iterator LI(LibDevicePath, EC), LE;
+      for (llvm::vfs::directory_iterator
+               LI = D.getVFS().dir_begin(LibDevicePath, EC),
+               LE;
            !EC && LI != LE; LI = LI.increment(EC)) {
         StringRef FilePath = LI->path();
         StringRef FileName = llvm::sys::path::filename(FilePath);
         // Process all bitcode filenames that look like
         // libdevice.compute_XX.YY.bc
         const StringRef LibDeviceName = "libdevice.";
         if (!(FileName.startswith(LibDeviceName) && FileName.endswith(".bc")))
           continue;