[bugpoint] Find 'opt', etc., in bugpoint directory
Summary:
When bugpoint attempts to find the other executables it needs to run,
such as `opt` or `clang`, it tries searching the user's PATH. However,
in many cases, the 'bugpoint' executable is part of an LLVM build, and
the 'opt' executable it's looking for is in that same directory.
Many LLVM tools handle this case by using the `Paths` parameter of
`llvm::sys::findProgramByName`, passing the parent path of the currently
running executable. Do this same thing for bugpoint. However, to
preserve the current behavior exactly, first search the user's PATH,
and then search for 'opt' in the directory containing 'bugpoint'.
Test Plan:
`check-llvm`. Many of the existing bugpoint tests no longer need to use the
`--opt-command` option as a result of these changes.
Reviewers: MatzeB, silvas, davide
Reviewed By: MatzeB, davide
Subscribers: davide, llvm-commits
Differential Revision: https://reviews.llvm.org/D54884
llvm-svn: 348734
diff --git a/llvm/tools/bugpoint/ExecutionDriver.cpp b/llvm/tools/bugpoint/ExecutionDriver.cpp
index 690a48d..1b86b10 100644
--- a/llvm/tools/bugpoint/ExecutionDriver.cpp
+++ b/llvm/tools/bugpoint/ExecutionDriver.cpp
@@ -148,8 +148,9 @@
std::string Message;
if (CCBinary.empty()) {
- if (sys::findProgramByName("clang"))
- CCBinary = "clang";
+ if (ErrorOr<std::string> ClangPath =
+ FindProgramByName("clang", getToolName(), &AbsTolerance))
+ CCBinary = *ClangPath;
else
CCBinary = "gcc";
}
@@ -193,11 +194,11 @@
break;
case CompileCustom:
Interpreter = AbstractInterpreter::createCustomCompiler(
- Message, CustomCompileCommand);
+ getToolName(), Message, CustomCompileCommand);
break;
case Custom:
- Interpreter =
- AbstractInterpreter::createCustomExecutor(Message, CustomExecCommand);
+ Interpreter = AbstractInterpreter::createCustomExecutor(
+ getToolName(), Message, CustomExecCommand);
break;
}
if (!Interpreter)
@@ -239,8 +240,8 @@
SafeInterpreterSel == RunLLCIA);
break;
case Custom:
- SafeInterpreter =
- AbstractInterpreter::createCustomExecutor(Message, CustomExecCommand);
+ SafeInterpreter = AbstractInterpreter::createCustomExecutor(
+ getToolName(), Message, CustomExecCommand);
break;
default:
Message = "Sorry, this back-end is not supported by bugpoint as the "
@@ -252,7 +253,7 @@
exit(1);
}
- cc = CC::create(Message, CCBinary, &CCToolArgv);
+ cc = CC::create(getToolName(), Message, CCBinary, &CCToolArgv);
if (!cc) {
outs() << Message << "\nExiting.\n";
exit(1);
diff --git a/llvm/tools/bugpoint/OptimizerDriver.cpp b/llvm/tools/bugpoint/OptimizerDriver.cpp
index cbb048d..64fe675 100644
--- a/llvm/tools/bugpoint/OptimizerDriver.cpp
+++ b/llvm/tools/bugpoint/OptimizerDriver.cpp
@@ -16,6 +16,7 @@
//===----------------------------------------------------------------------===//
#include "BugDriver.h"
+#include "ToolRunner.h"
#include "llvm/Bitcode/BitcodeWriter.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Module.h"
@@ -166,7 +167,8 @@
std::string tool = OptCmd;
if (OptCmd.empty()) {
- if (ErrorOr<std::string> Path = sys::findProgramByName("opt"))
+ if (ErrorOr<std::string> Path =
+ FindProgramByName("opt", getToolName(), &OutputPrefix))
tool = *Path;
else
errs() << Path.getError().message() << "\n";
diff --git a/llvm/tools/bugpoint/ToolRunner.cpp b/llvm/tools/bugpoint/ToolRunner.cpp
index 812e8e3..7ba8ea1 100644
--- a/llvm/tools/bugpoint/ToolRunner.cpp
+++ b/llvm/tools/bugpoint/ToolRunner.cpp
@@ -202,19 +202,7 @@
void AbstractInterpreter::anchor() {}
-#if defined(LLVM_ON_UNIX)
-const char EXESuffix[] = "";
-#elif defined(_WIN32)
-const char EXESuffix[] = "exe";
-#endif
-
-/// Prepend the path to the program being executed
-/// to \p ExeName, given the value of argv[0] and the address of main()
-/// itself. This allows us to find another LLVM tool if it is built in the same
-/// directory. An empty string is returned on error; note that this function
-/// just mainpulates the path and doesn't check for executability.
-/// Find a named executable.
-static std::string PrependMainExecutablePath(const std::string &ExeName,
+ErrorOr<std::string> llvm::FindProgramByName(const std::string &ExeName,
const char *Argv0,
void *MainAddr) {
// Check the directory that the calling program is in. We can do
@@ -222,30 +210,25 @@
// is a relative path to the executable itself.
std::string Main = sys::fs::getMainExecutable(Argv0, MainAddr);
StringRef Result = sys::path::parent_path(Main);
+ if (ErrorOr<std::string> Path = sys::findProgramByName(ExeName, Result))
+ return *Path;
- if (!Result.empty()) {
- SmallString<128> Storage = Result;
- sys::path::append(Storage, ExeName);
- sys::path::replace_extension(Storage, EXESuffix);
- return Storage.str();
- }
-
- return Result.str();
+ // Check the user PATH.
+ return sys::findProgramByName(ExeName);
}
// LLI create method - Try to find the LLI executable
AbstractInterpreter *
AbstractInterpreter::createLLI(const char *Argv0, std::string &Message,
const std::vector<std::string> *ToolArgs) {
- std::string LLIPath =
- PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t)&createLLI);
- if (!LLIPath.empty()) {
- Message = "Found lli: " + LLIPath + "\n";
- return new LLI(LLIPath, ToolArgs);
+ if (ErrorOr<std::string> LLIPath =
+ FindProgramByName("lli", Argv0, (void *)(intptr_t)&createLLI)) {
+ Message = "Found lli: " + *LLIPath + "\n";
+ return new LLI(*LLIPath, ToolArgs);
+ } else {
+ Message = LLIPath.getError().message() + "\n";
+ return nullptr;
}
-
- Message = "Cannot find `lli' in executable directory!\n";
- return nullptr;
}
//===---------------------------------------------------------------------===//
@@ -368,8 +351,9 @@
// '\ ' -> ' '
// 'exa\mple' -> 'example'
//
-static void lexCommand(std::string &Message, const std::string &CommandLine,
- std::string &CmdPath, std::vector<std::string> &Args) {
+static void lexCommand(const char *Argv0, std::string &Message,
+ const std::string &CommandLine, std::string &CmdPath,
+ std::vector<std::string> &Args) {
std::string Token;
std::string Command;
@@ -402,7 +386,7 @@
Token.push_back(CommandLine[Pos]);
}
- auto Path = sys::findProgramByName(Command);
+ auto Path = FindProgramByName(Command, Argv0, (void *)(intptr_t)&lexCommand);
if (!Path) {
Message = std::string("Cannot find '") + Command +
"' in PATH: " + Path.getError().message() + "\n";
@@ -416,11 +400,12 @@
// Custom execution environment create method, takes the execution command
// as arguments
AbstractInterpreter *AbstractInterpreter::createCustomCompiler(
- std::string &Message, const std::string &CompileCommandLine) {
+ const char *Argv0, std::string &Message,
+ const std::string &CompileCommandLine) {
std::string CmdPath;
std::vector<std::string> Args;
- lexCommand(Message, CompileCommandLine, CmdPath, Args);
+ lexCommand(Argv0, Message, CompileCommandLine, CmdPath, Args);
if (CmdPath.empty())
return nullptr;
@@ -430,12 +415,13 @@
// Custom execution environment create method, takes the execution command
// as arguments
AbstractInterpreter *
-AbstractInterpreter::createCustomExecutor(std::string &Message,
+AbstractInterpreter::createCustomExecutor(const char *Argv0,
+ std::string &Message,
const std::string &ExecCommandLine) {
std::string CmdPath;
std::vector<std::string> Args;
- lexCommand(Message, ExecCommandLine, CmdPath, Args);
+ lexCommand(Argv0, Message, ExecCommandLine, CmdPath, Args);
if (CmdPath.empty())
return nullptr;
@@ -524,20 +510,20 @@
const std::vector<std::string> *Args,
const std::vector<std::string> *CCArgs,
bool UseIntegratedAssembler) {
- std::string LLCPath =
- PrependMainExecutablePath("llc", Argv0, (void *)(intptr_t)&createLLC);
- if (LLCPath.empty()) {
- Message = "Cannot find `llc' in executable directory!\n";
+ ErrorOr<std::string> LLCPath =
+ FindProgramByName("llc", Argv0, (void *)(intptr_t)&createLLC);
+ if (!LLCPath) {
+ Message = LLCPath.getError().message() + "\n";
return nullptr;
}
- CC *cc = CC::create(Message, CCBinary, CCArgs);
+ CC *cc = CC::create(Argv0, Message, CCBinary, CCArgs);
if (!cc) {
errs() << Message << "\n";
exit(1);
}
- Message = "Found llc: " + LLCPath + "\n";
- return new LLC(LLCPath, cc, Args, UseIntegratedAssembler);
+ Message = "Found llc: " + *LLCPath + "\n";
+ return new LLC(*LLCPath, cc, Args, UseIntegratedAssembler);
}
//===---------------------------------------------------------------------===//
@@ -606,15 +592,14 @@
AbstractInterpreter *
AbstractInterpreter::createJIT(const char *Argv0, std::string &Message,
const std::vector<std::string> *Args) {
- std::string LLIPath =
- PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t)&createJIT);
- if (!LLIPath.empty()) {
- Message = "Found lli: " + LLIPath + "\n";
- return new JIT(LLIPath, Args);
+ if (ErrorOr<std::string> LLIPath =
+ FindProgramByName("lli", Argv0, (void *)(intptr_t)&createJIT)) {
+ Message = "Found lli: " + *LLIPath + "\n";
+ return new JIT(*LLIPath, Args);
+ } else {
+ Message = LLIPath.getError().message() + "\n";
+ return nullptr;
}
-
- Message = "Cannot find `lli' in executable directory!\n";
- return nullptr;
}
//===---------------------------------------------------------------------===//
@@ -855,9 +840,10 @@
/// create - Try to find the CC executable
///
-CC *CC::create(std::string &Message, const std::string &CCBinary,
+CC *CC::create(const char *Argv0, std::string &Message,
+ const std::string &CCBinary,
const std::vector<std::string> *Args) {
- auto CCPath = sys::findProgramByName(CCBinary);
+ auto CCPath = FindProgramByName(CCBinary, Argv0, (void *)(intptr_t)&create);
if (!CCPath) {
Message = "Cannot find `" + CCBinary + "' in PATH: " +
CCPath.getError().message() + "\n";
diff --git a/llvm/tools/bugpoint/ToolRunner.h b/llvm/tools/bugpoint/ToolRunner.h
index f218ad5..ef8551c 100644
--- a/llvm/tools/bugpoint/ToolRunner.h
+++ b/llvm/tools/bugpoint/ToolRunner.h
@@ -49,7 +49,8 @@
public:
enum FileType { AsmFile, ObjectFile, CFile };
- static CC *create(std::string &Message, const std::string &CCBinary,
+ static CC *create(const char *Argv0, std::string &Message,
+ const std::string &CCBinary,
const std::vector<std::string> *Args);
/// ExecuteProgram - Execute the program specified by "ProgramFile" (which is
@@ -98,11 +99,11 @@
const std::vector<std::string> *Args = nullptr);
static AbstractInterpreter *
- createCustomCompiler(std::string &Message,
+ createCustomCompiler(const char *Argv0, std::string &Message,
const std::string &CompileCommandLine);
static AbstractInterpreter *
- createCustomExecutor(std::string &Message,
+ createCustomExecutor(const char *Argv0, std::string &Message,
const std::string &ExecCommandLine);
virtual ~AbstractInterpreter() {}
@@ -178,6 +179,13 @@
unsigned MemoryLimit = 0) override;
};
+/// Find the first executable file \ExeName, either in the user's PATH or,
+/// failing that, in the same directory as argv[0]. This allows us to find
+/// another LLVM tool if it is built in the same directory. If no executable is
+/// found, an error is returned.
+ErrorOr<std::string> FindProgramByName(const std::string &ExeName,
+ const char *Argv0, void *MainAddr);
+
} // End llvm namespace
#endif