RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-04-02 15:51:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Replace use of PathV1.h in Program.cpp.

Browse Source 
llvm-svn: 183996
This commit is contained in:
Rafael Espindola 2013-06-14 19:38:45 +00:00
parent 9aa8b92dda
commit 109393c56d
6 changed files with 69 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/Support/FileSystem.h
View File

@ -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.

32
lib/Support/Program.cpp
View File

@ -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,

7
lib/Support/Unix/PathV2.inc
View File

@ -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 &&

56
lib/Support/Unix/Program.inc
View File

@ -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) {

11
lib/Support/Windows/PathV2.inc
View File

@ -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 &&

32
lib/Support/Windows/Program.inc
View File

@ -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);