6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-14 00:32:55 +00:00
Code Issues Projects Releases Wiki Activity

Remove FindProgramByName. NFC.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@221258 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2014-11-04 12:35:47 +00:00
parent 3f4bf44b1c
commit 5dac5bd225
4 changed files with 5 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/llvm/Support/Program.h
View File

@ -52,18 +52,6 @@ struct ProcessInfo {
ProcessInfo();
};
/// This function attempts to locate a program in the operating
/// system's file system using some pre-determined set of locations to search
/// (e.g. the PATH on Unix). Paths with slashes are returned unmodified.
///
/// It does not perform hashing as a shell would but instead stats each PATH
/// entry individually so should generally be avoided. Core LLVM library
/// functions and options should instead require fully specified paths.
///
/// @returns A string containing the path of the program or an empty string if
/// the program could not be found.
std::string FindProgramByName(const std::string& name);
/// \brief Find the first executable file \p Name in \p Paths.
///
/// This does not perform hashing as a shell would but instead stats each PATH
@ -100,7 +88,7 @@ struct ProcessInfo {
/// -2 indicates a crash during execution or timeout
int ExecuteAndWait(
StringRef Program, ///< Path of the program to be executed. It is
/// presumed this is the result of the FindProgramByName method.
/// presumed this is the result of the findProgramByName method.
const char **args, ///< A vector of strings that are passed to the
///< program. The first element should be the name of the program.
///< The list *must* be terminated by a null char* entry.

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

@ -55,52 +55,6 @@ using namespace sys;
ProcessInfo::ProcessInfo() : Pid(0), ReturnCode(0) {}
// This function just uses the PATH environment variable to find the program.
std::string
sys::FindProgramByName(const std::string& progName) {
// Check some degenerate cases
if (progName.length() == 0) // no program
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;
// 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.
// Get the path. If its empty, we can't do anything to find it.
const char *PathStr = getenv("PATH");
if (!PathStr)
return "";
// Now we have a colon separated list of directories to search; try them.
size_t PathLen = strlen(PathStr);
while (PathLen) {
// Find the first colon...
const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
// Check to see if this first directory contains 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;
PathStr = Colon;
// Advance past duplicate colons
while (*PathStr == ':') {
PathStr++;
PathLen--;
}
}
return "";
}
ErrorOr<std::string> sys::findProgramByName(StringRef Name,
ArrayRef<StringRef> Paths) {
assert(!Name.empty() && "Must have a name!");

6
lib/Support/Unix/Signals.inc
View File

@ -328,9 +328,11 @@ static bool printSymbolizedStackTrace(void **StackTrace, int Depth, FILE *FD) {
// FIXME: Subtract necessary number from StackTrace entries to turn return addresses
// into actual instruction addresses.
// Use llvm-symbolizer tool to symbolize the stack traces.
std::string LLVMSymbolizerPath = sys::FindProgramByName("llvm-symbolizer");
if (LLVMSymbolizerPath.empty())
ErrorOr<std::string> LLVMSymbolizerPathOrErr =
sys::findProgramByName("llvm-symbolizer");
if (!LLVMSymbolizerPathOrErr)
return false;
const std::string &LLVMSymbolizerPath = *LLVMSymbolizerPathOrErr;
// We don't know argv0 or the address of main() at this point, but try
// to guess it anyway (it's possible on some platforms).
std::string MainExecutableName = sys::fs::getMainExecutable(nullptr, nullptr);

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

@ -32,45 +32,6 @@ using namespace sys;
ProcessInfo::ProcessInfo() : ProcessHandle(0), Pid(0), ReturnCode(0) {}
// This function just uses the PATH environment variable to find the program.
std::string sys::FindProgramByName(const std::string &progName) {
// Check some degenerate cases
if (progName.length() == 0) // no program
return "";
std::string temp = progName;
// Return paths with slashes verbatim.
if (progName.find('\\') != std::string::npos ||
progName.find('/') != std::string::npos)
return temp;
// At this point, the file name is valid and does not contain slashes.
// Let Windows search for it.
SmallVector<wchar_t, MAX_PATH> progNameUnicode;
if (windows::UTF8ToUTF16(progName, progNameUnicode))
return "";
SmallVector<wchar_t, MAX_PATH> buffer;
DWORD len = MAX_PATH;
do {
buffer.reserve(len);
len = ::SearchPathW(NULL, progNameUnicode.data(), L".exe",
buffer.capacity(), buffer.data(), NULL);
// See if it wasn't found.
if (len == 0)
return "";
// Buffer was too small; grow and retry.
} while (len > buffer.capacity());
buffer.set_size(len);
SmallVector<char, MAX_PATH> result;
if (windows::UTF16ToUTF8(buffer.begin(), buffer.size(), result))
return "";
return std::string(result.data(), result.size());
}
ErrorOr<std::string> sys::findProgramByName(StringRef Name,
ArrayRef<StringRef> Paths) {
assert(!Name.empty() && "Must have a name!");