Replace use of PathV1.h in Program.cpp.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@183996 91177308-0d34-0410-b5e6-96231b3b80d8

6 files changed, 69 insertions, 75 deletions

diff --git a/include/llvm/Support/FileSystem.h b/include/llvm/Support/FileSystem.h
index 570b34b6b23..f84c142aa15 100644
--- a/include/llvm/Support/FileSystem.h
+++ b/include/llvm/Support/FileSystem.h
@@ -342,6 +342,12 @@ inline bool exists(const Twine &path) {
   return !exists(path, result) && result;
 }
 
+/// @brief Can we execute this file?
+///
+/// @param Path Input path.
+/// @returns True if we can execute it, false otherwise.
+bool can_execute(const Twine &Path);
+
 /// @brief Do file_status's represent the same thing?
 ///
 /// @param A Input file_status.
diff --git a/lib/Support/Program.cpp b/lib/Support/Program.cpp
index 52208b047d1..79f7e5fbb7e 100644
--- a/lib/Support/Program.cpp
+++ b/lib/Support/Program.cpp
@@ -12,7 +12,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Program.h"
-#include "llvm/Support/PathV1.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/system_error.h"
 using namespace llvm;
@@ -23,39 +22,12 @@ using namespace sys;
 //===          independent code.
 //===----------------------------------------------------------------------===//
 
-static bool Execute(void **Data, const Path &path, const char **args,
-                    const char **env, const sys::Path **redirects,
-                    unsigned memoryLimit, std::string *ErrMsg);
-
-static int Wait(void *&Data, const Path &path, unsigned secondsToWait,
-                std::string *ErrMsg);
-
-
 static bool Execute(void **Data, StringRef Program, const char **args,
                     const char **env, const StringRef **Redirects,
-                    unsigned memoryLimit, std::string *ErrMsg) {
-  Path P(Program);
-  if (!Redirects)
-    return Execute(Data, P, args, env, 0, memoryLimit, ErrMsg);
-  Path IO[3];
-  const Path *IOP[3];
-  for (int I = 0; I < 3; ++I) {
-    if (Redirects[I]) {
-      IO[I] = *Redirects[I];
-      IOP[I] = &IO[I];
-    } else {
-      IOP[I] = 0;
-    }
-  }
-
-  return Execute(Data, P, args, env, IOP, memoryLimit, ErrMsg);
-}
+                    unsigned memoryLimit, std::string *ErrMsg);
 
 static int Wait(void *&Data, StringRef Program, unsigned secondsToWait,
-                std::string *ErrMsg) {
-  Path P(Program);
-  return Wait(Data, P, secondsToWait, ErrMsg);
-}
+                std::string *ErrMsg);
 
 int sys::ExecuteAndWait(StringRef Program, const char **args, const char **envp,
                         const StringRef **redirects, unsigned secondsToWait,
diff --git a/lib/Support/Unix/PathV2.inc b/lib/Support/Unix/PathV2.inc
index 7e0aead151b..df8841220b5 100644
--- a/lib/Support/Unix/PathV2.inc
+++ b/lib/Support/Unix/PathV2.inc
@@ -292,6 +292,13 @@ error_code exists(const Twine &path, bool &result) {
   return error_code::success();
 }
 
+bool can_execute(const Twine &Path) {
+  SmallString<128> PathStorage;
+  StringRef P = Path.toNullTerminatedStringRef(PathStorage);
+
+  return ::access(P.begin(), X_OK) != -1;
+}
+
 bool equivalent(file_status A, file_status B) {
   assert(status_known(A) && status_known(B));
   return A.fs_st_dev == B.fs_st_dev &&
diff --git a/lib/Support/Unix/Program.inc b/lib/Support/Unix/Program.inc
index 5fa421b917f..8676642b74a 100644
--- a/lib/Support/Unix/Program.inc
+++ b/lib/Support/Unix/Program.inc
@@ -54,13 +54,11 @@ sys::FindProgramByName(const std::string& progName) {
   // Check some degenerate cases
   if (progName.length() == 0) // no program
     return "";
-  Path temp;
-  if (!temp.set(progName)) // invalid name
-    return "";
+  std::string temp = progName;
   // Use the given path verbatim if it contains any slashes; this matches
   // the behavior of sh(1) and friends.
   if (progName.find('/') != std::string::npos)
-    return temp.str();
+    return temp;
 
   // At this point, the file name is valid and does not contain slashes. Search
   // for it through the directories specified in the PATH environment variable.
@@ -77,12 +75,10 @@ sys::FindProgramByName(const std::string& progName) {
     const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
 
     // Check to see if this first directory contains the executable...
-    Path FilePath;
-    if (FilePath.set(std::string(PathStr,Colon))) {
-      FilePath.appendComponent(progName);
-      if (FilePath.canExecute())
-        return FilePath.str();                    // Found the executable!
-    }
+    SmallString<128> FilePath(PathStr,Colon);
+    sys::path::append(FilePath, progName);
+    if (sys::fs::can_execute(Twine(FilePath)))
+      return FilePath.str();                    // Found the executable!
 
     // Nope it wasn't in this directory, check the next path in the list!
     PathLen -= Colon-PathStr;
@@ -97,20 +93,20 @@ sys::FindProgramByName(const std::string& progName) {
   return "";
 }
 
-static bool RedirectIO(const Path *Path, int FD, std::string* ErrMsg) {
+static bool RedirectIO(const StringRef *Path, int FD, std::string* ErrMsg) {
   if (Path == 0) // Noop
     return false;
-  const char *File;
-  if (Path->isEmpty())
+  std::string File;
+  if (Path->empty())
     // Redirect empty paths to /dev/null
     File = "/dev/null";
   else
-    File = Path->c_str();
+    File = *Path;
 
   // Open the file
-  int InFD = open(File, FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
+  int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
   if (InFD == -1) {
-    MakeErrMsg(ErrMsg, "Cannot open file '" + std::string(File) + "' for "
+    MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
               + (FD == 0 ? "input" : "output"));
     return true;
   }
@@ -126,19 +122,20 @@ static bool RedirectIO(const Path *Path, int FD, std::string* ErrMsg) {
 }
 
 #ifdef HAVE_POSIX_SPAWN
-static bool RedirectIO_PS(const Path *Path, int FD, std::string *ErrMsg,
+static bool RedirectIO_PS(const StringRef *Path, int FD, std::string *ErrMsg,
                           posix_spawn_file_actions_t *FileActions) {
   if (Path == 0) // Noop
     return false;
-  const char *File;
-  if (Path->isEmpty())
+  std::string File;
+  if (Path->empty())
     // Redirect empty paths to /dev/null
     File = "/dev/null";
   else
-    File = Path->c_str();
+    File = *Path;
 
-  if (int Err = posix_spawn_file_actions_addopen(FileActions, FD,
-                            File, FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666))
+  if (int Err = posix_spawn_file_actions_addopen(
+          FileActions, FD, File.c_str(),
+          FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
     return MakeErrMsg(ErrMsg, "Cannot dup2", Err);
   return false;
 }
@@ -178,8 +175,8 @@ static void SetMemoryLimits (unsigned size)
 
 }
 
-static bool Execute(void **Data, const Path &path, const char **args,
-                    const char **envp, const Path **redirects,
+static bool Execute(void **Data, StringRef Program, const char **args,
+                    const char **envp, const StringRef **redirects,
                     unsigned memoryLimit, std::string *ErrMsg) {
   // If this OS has posix_spawn and there is no memory limit being implied, use
   // posix_spawn.  It is more efficient than fork/exec.
@@ -219,7 +216,7 @@ static bool Execute(void **Data, const Path &path, const char **args,
     // Explicitly initialized to prevent what appears to be a valgrind false
     // positive.
     pid_t PID = 0;
-    int Err = posix_spawn(&PID, path.c_str(), FileActions, /*attrp*/0,
+    int Err = posix_spawn(&PID, Program.str().c_str(), FileActions, /*attrp*/0,
                           const_cast<char **>(args), const_cast<char **>(envp));
 
     if (FileActions)
@@ -270,12 +267,13 @@ static bool Execute(void **Data, const Path &path, const char **args,
       }
 
       // Execute!
+      std::string PathStr = Program;
       if (envp != 0)
-        execve(path.c_str(),
+        execve(PathStr.c_str(),
                const_cast<char **>(args),
                const_cast<char **>(envp));
       else
-        execv(path.c_str(),
+        execv(PathStr.c_str(),
               const_cast<char **>(args));
       // If the execve() failed, we should exit. Follow Unix protocol and
       // return 127 if the executable was not found, and 126 otherwise.
@@ -297,7 +295,7 @@ static bool Execute(void **Data, const Path &path, const char **args,
   return true;
 }
 
-static int Wait(void *&Data, const sys::Path &path, unsigned secondsToWait,
+static int Wait(void *&Data, StringRef Program, unsigned secondsToWait,
                 std::string *ErrMsg) {
 #ifdef HAVE_SYS_WAIT_H
   struct sigaction Act, Old;
@@ -356,7 +354,7 @@ static int Wait(void *&Data, const sys::Path &path, unsigned secondsToWait,
     // itself apparently does not), check to see if the failure was due to some
     // reason other than the file not existing, and return 126 in this case.
     bool Exists;
-    if (result == 127 && !llvm::sys::fs::exists(path.str(), Exists) && Exists)
+    if (result == 127 && !llvm::sys::fs::exists(Program, Exists) && Exists)
       result = 126;
 #endif
     if (result == 127) {
diff --git a/lib/Support/Windows/PathV2.inc b/lib/Support/Windows/PathV2.inc
index 23f3d14f91f..ea383895f2a 100644
--- a/lib/Support/Windows/PathV2.inc
+++ b/lib/Support/Windows/PathV2.inc
@@ -362,6 +362,17 @@ error_code exists(const Twine &path, bool &result) {
   return error_code::success();
 }
 
+bool can_execute(const Twine &Path) {
+  SmallString<128> PathStorage;
+  SmallVector<wchar_t, 128> PathUtf16;
+
+  if (UTF8ToUTF16(Path.toStringRef(PathStorage), PathUtf16))
+    return false;
+
+  DWORD Attr = ::GetFileAttributesW(PathUtf16.begin());
+  return Attr != INVALID_FILE_ATTRIBUTES;
+}
+
 bool equivalent(file_status A, file_status B) {
   assert(status_known(A) && status_known(B));
   return A.FileIndexHigh      == B.FileIndexHigh &&
diff --git a/lib/Support/Windows/Program.inc b/lib/Support/Windows/Program.inc
index ee0f9074286..a368407960c 100644
--- a/lib/Support/Windows/Program.inc
+++ b/lib/Support/Windows/Program.inc
@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "Windows.h"
+#include "llvm/Support/FileSystem.h"
 #include <cstdio>
 #include <fcntl.h>
 #include <io.h>
@@ -37,13 +38,11 @@ std::string sys::FindProgramByName(const std::string &progName) {
   // Check some degenerate cases
   if (progName.length() == 0) // no program
     return "";
-  Path temp;
-  if (!temp.set(progName)) // invalid name
-    return "";
+  std::string temp = progName;
   // Return paths with slashes verbatim.
   if (progName.find('\\') != std::string::npos ||
       progName.find('/') != std::string::npos)
-    return temp.str();
+    return temp;
 
   // At this point, the file name is valid and does not contain slashes.
   // Let Windows search for it.
@@ -76,7 +75,7 @@ std::string sys::FindProgramByName(const std::string &progName) {
   }
 }
 
-static HANDLE RedirectIO(const Path *path, int fd, std::string* ErrMsg) {
+static HANDLE RedirectIO(const StringRef *path, int fd, std::string* ErrMsg) {
   HANDLE h;
   if (path == 0) {
     DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
@@ -85,19 +84,19 @@ static HANDLE RedirectIO(const Path *path, int fd, std::string* ErrMsg) {
     return h;
   }
 
-  const char *fname;
-  if (path->isEmpty())
+  std::string fname;
+  if (path->empty())
     fname = "NUL";
   else
-    fname = path->c_str();
+    fname = *path;
 
   SECURITY_ATTRIBUTES sa;
   sa.nLength = sizeof(sa);
   sa.lpSecurityDescriptor = 0;
   sa.bInheritHandle = TRUE;
 
-  h = CreateFile(fname, fd ? GENERIC_WRITE : GENERIC_READ, FILE_SHARE_READ,
-                 &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
+  h = CreateFile(fname.c_str(), fd ? GENERIC_WRITE : GENERIC_READ,
+                 FILE_SHARE_READ, &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
                  FILE_ATTRIBUTE_NORMAL, NULL);
   if (h == INVALID_HANDLE_VALUE) {
     MakeErrMsg(ErrMsg, std::string(fname) + ": Can't open file for " +
@@ -171,13 +170,13 @@ static unsigned int ArgLenWithQuotes(const char *Str) {
 }
 
 static bool Execute(void **Data,
-                    const Path& path,
+                    StringRef Program,
                     const char** args,
                     const char** envp,
-                    const Path** redirects,
+                    const StringRef** redirects,
                     unsigned memoryLimit,
                     std::string* ErrMsg) {
-  if (!path.canExecute()) {
+  if (!sys::fs::can_execute(Program)) {
     if (ErrMsg)
       *ErrMsg = "program not executable";
     return false;
@@ -297,7 +296,8 @@ static bool Execute(void **Data,
 
   fflush(stdout);
   fflush(stderr);
-  BOOL rc = CreateProcess(path.c_str(), command, NULL, NULL, TRUE, 0,
+  std::string ProgramStr = Program;
+  BOOL rc = CreateProcess(ProgramStr.c_str(), command, NULL, NULL, TRUE, 0,
                           envblock, NULL, &si, &pi);
   DWORD err = GetLastError();
 
@@ -311,7 +311,7 @@ static bool Execute(void **Data,
   if (!rc) {
     SetLastError(err);
     MakeErrMsg(ErrMsg, std::string("Couldn't execute program '") +
-               path.str() + "'");
+               ProgramStr + "'");
     return false;
   }
   if (Data) {
@@ -398,7 +398,7 @@ static int WaitAux(Win32ProcessInfo *wpi, unsigned secondsToWait,
   return 1;
 }
 
-static int Wait(void *&Data, const Path &path, unsigned secondsToWait,
+static int Wait(void *&Data, StringRef Program, unsigned secondsToWait,
                 std::string *ErrMsg) {
   Win32ProcessInfo *wpi = reinterpret_cast<Win32ProcessInfo *>(Data);
   int Ret = WaitAux(wpi, secondsToWait, ErrMsg);