[bugpoint] Find 'opt', etc., in bugpoint directory

[modocache]

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.

[modocache]

Friendly ping! I like this patch because it saves me the keystrokes of typing --opt-command every time I run bugpoint. Please give it a look and let me know if I can improve anything.

@MatzeB, I noticed you had created a few bugpoint bugs on Bugzilla related to bugpoint; would you be a good person to review this?

[davide]

As somebody who used bugpoint fairly extensively over the course of the years, I have to say I always considered a little error prone the fact that bugpoint looks up in the PATH to find opt.
So, I tend to be in favor of this patch, but I'm wondering whether it's worth to look in the $PATH instead of just looking in the current directory.
Realistically bugpoint is a tool for developers, so chances are you're going to run it directly from bin using the compiler/interpreter/assembler you just built.

You might consider asking on llvm-dev how people use the tool, and if there are no strong objections, we might be able to change the behavior. Other than that, the patch looks straightforward enough.

[davide]

LGTM conditional to lack of objections from people on llvm-dev.

[MatzeB]

I certainly was always annoyed that bugpoint wouldn't pick up the tools in the same build directory forcing me to manually specify paths to the tools.
However unfortunately this isn't going far enough and will still search the tools in PATH first, which can still be annoying as in my experience you can often have llvm developer tools installed by your distribution/package managers etc. in your PATH.

So while I'm fine applying this patch (with the test problems addressed), I'd even vote to search inside the bugpoint directory first before checking the PATH. Happy to hear some other opinions though and/or apply this in the meantime.

test/BugPoint/compile-custom.ll

1

Won't this pick up an opt in the PATH now if one is available? That would make the test unstable.

Similar in the other tests.

[modocache]

Thanks @MatzeB! I'll change this to search in the bugpoint directory first, and fall back to the PATH.

I also responded to your comments on the test. As I mention in the comment there, I think that once I change the search behavior and confirm all tests still pass, this patch seems good enough to commit. Let me know if you disagree!

test/BugPoint/compile-custom.ll

1

Oh, I see. I didn't realize that LLVM's test/lit.cfg.py provides a substitution named opt -- so this actually expands to the lit command --opt-command /path/to/build/bin/opt:

# llvm/test/lit.cfg.py

tools.extend([
    # ...
    'verify-uselistorder', 'bugpoint', 'llc', 'llvm-symbolizer', 'opt',
    'sancov', 'sanstats'])

# ...

llvm_config.add_tool_substitutions(tools, config.llvm_tools_dir)

However, I believe the tests are still stable after this change, and here's why: test/lit.cfg.py also inserts the built LLVM tools directory at the beginning of the PATH when running tests:

# Tweak the PATH to include the tools dir.
llvm_config.with_environment('PATH', config.llvm_tools_dir, append_path=True)

So during the test run, /path/to/build/bin is always the first item in the PATH. Since the default behavior of bugpoint is to try and find opt in the PATH when no --opt-command is specified, removing this option has no material impact on the tests.

So this means two things:

1. The usages of --opt-command in the bugpoint tests could all be removed today, even without this patch, as long as lit.cfg.py continues to prepend the tools directory to the PATH when running tests.
2. Since these options can be removed even without this patch, removing them isn't a sufficient way to test the behavior in this diff. Still, I think removing the usage of the options, and changing the behavior of bugpoint so it searches in the bugpoint executable's directory first, might be a "good enough" test of the new behavior. The only alternative I can think of is having a test that copies the bugpoint executable into a temporary directory, copying a test programmed named "opt" into that same directory, and invoking bugpoint in some way that demonstrates the "opt" from the temporary directory is chosen... and that seems like overkill to test this minor convenience.

[modocache]

Search the bugpoint directory first, and only fall back to PATH if the program isn't there.

test/BugPoint/compile-custom.ll

-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext --compile-custom --compile-command="%python %/s.py arg1 arg2" --opt-command opt --output-prefix %t %s | FileCheck %s
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext --compile-custom --compile-command="%python %/s.py arg1 arg2" --output-prefix %t %s | FileCheck %s
 ; REQUIRES: loadable_module
 
 ; Test that arguments are correctly passed in --compile-command.  The output
 ; of bugpoint includes the output of the custom tool, so we just echo the args
 ; in the tool and check here.
 
 ; CHECK: Error: arg1 arg2
 
 define void @noop() {
     ret void
 }

test/BugPoint/crash-narrowfunctiontest.ll

 ; Test that bugpoint can narrow down the testcase to the important function
 ;
-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crashcalls --opt-command opt -silence-passes > /dev/null
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crashcalls -silence-passes > /dev/null
 ; REQUIRES: loadable_module
 
 define i32 @foo() { ret i32 1 }
 
 define i32 @test() {
   call i32 @test()
   ret i32 %1
 }
 
 define i32 @bar() { ret i32 2 }

test/BugPoint/invalid-debuginfo.ll

-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crash-too-many-cus -silence-passes --opt-command opt 2>&1 | FileCheck %s
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crash-too-many-cus -silence-passes 2>&1 | FileCheck %s
 ; REQUIRES: loadable_module
 ; CHECK: DICompileUnit not listed in llvm.dbg.cu
 
 ; When bugpoint hacks at this testcase it will at one point create illegal IR
 ; that won't even pass the Verifier. A bugpoint *driver* built with assertions
 ; should not assert on it, but reject the malformed intermediate step.
 define void @f() !dbg !9 { ret void }
 !llvm.dbg.cu = !{!0, !1, !2, !3, !4, !5}

test/BugPoint/metadata.ll

 ; REQUIRES: loadable_module
-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crashcalls -silence-passes -disable-namedmd-remove -disable-strip-debuginfo -disable-strip-debug-types --opt-command opt > /dev/null
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crashcalls -silence-passes -disable-namedmd-remove -disable-strip-debuginfo -disable-strip-debug-types > /dev/null
 ; RUN: llvm-dis %t-reduced-simplified.bc -o - | FileCheck %s
 ;
-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t-nodebug -bugpoint-crashcalls -silence-passes -disable-namedmd-remove --opt-command opt > /dev/null
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t-nodebug -bugpoint-crashcalls -silence-passes -disable-namedmd-remove > /dev/null
 ; RUN: llvm-dis %t-nodebug-reduced-simplified.bc -o - | FileCheck %s --check-prefix=NODEBUG
 ;
-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t-notype -bugpoint-crashcalls -silence-passes -disable-namedmd-remove -disable-strip-debuginfo --opt-command opt > /dev/null
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t-notype -bugpoint-crashcalls -silence-passes -disable-namedmd-remove -disable-strip-debuginfo > /dev/null
 ; RUN: llvm-dis %t-notype-reduced-simplified.bc -o - | FileCheck %s --check-prefix=NOTYPE
 ;
 ; Bugpoint should keep the call's metadata attached to the call.
 
 ; CHECK: call void @foo(), !dbg ![[LOC:[0-9]+]], !attach ![[CALL:[0-9]+]]
 ; NODEBUG: call void @foo(), !attach ![[CALL:[0-9]+]]
 ; NOTYPE: call void @foo(), !dbg ![[LOC:[0-9]+]], !attach ![[CALL:[0-9]+]]
 ; NODEBUG-NOT: call void @foo(), !attach ![[CALL:[0-9]+]]

test/BugPoint/named-md.ll

-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crash-too-many-cus -silence-passes -disable-strip-debuginfo --opt-command opt > /dev/null
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crash-too-many-cus -silence-passes -disable-strip-debuginfo > /dev/null
 ; RUN: llvm-dis %t-reduced-simplified.bc -o - | FileCheck %s
 ; RUN-DISABLE: bugpoint -disable-namedmd-remove -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crash-too-many-cus -silence-passes > /dev/null
 ; RUN-DISABLE: llvm-dis %t-reduced-simplified.bc -o - | FileCheck %s
 ; REQUIRES: loadable_module
 
 ; CHECK: !llvm.dbg.cu = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]]}
 ; CHECK-DISABLE:      !llvm.dbg.cu = !{![[FIRST:[0-9]+]], ![[SECOND:[0-9]+]],
 ; CHECK-DISABLE-SAME: ![[THIRD:[0-9]+]], ![[FOURTH:[0-9]+]], ![[FIFTH:[0-9]+]]}

test/BugPoint/remove_arguments_test.ll

-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crashcalls -silence-passes --opt-command opt
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -bugpoint-crashcalls -silence-passes
 ; RUN: llvm-dis %t-reduced-simplified.bc -o - | FileCheck %s
 ; REQUIRES: loadable_module
 
 ; Test to make sure that arguments are removed from the function if they are
 ; unnecessary. And clean up any types that frees up too.
 
 ; CHECK: ModuleID
 ; CHECK-NOT: struct.anon

test/BugPoint/replace-funcs-with-null.ll

 ; Test that bugpoint can reduce the set of functions by replacing them with null.
 ;
-; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -replace-funcs-with-null -bugpoint-crash-decl-funcs -silence-passes -safe-run-llc --opt-command opt
+; RUN: bugpoint -load %llvmshlibdir/BugpointPasses%shlibext %s -output-prefix %t -replace-funcs-with-null -bugpoint-crash-decl-funcs -silence-passes -safe-run-llc
 ; REQUIRES: loadable_module
 
 @foo2 = alias i32 (), i32 ()* @foo
 
 define i32 @foo() { ret i32 1 }
 
 define i32 @test() {
   call i32 @test()
   ret i32 %1
 }
 
 define i32 @bar() { ret i32 2 }
 
 @llvm.used = appending global [1 x i8*] [i8* bitcast (i32 ()* @foo to i8*)], section "llvm.metadata"

tools/bugpoint/ExecutionDriver.cpp

Error BugDriver::initializeExecutionEnvironment() {
   outs() << "Initializing execution environment: ";
 
   // Create an instance of the AbstractInterpreter interface as specified on
   // the command line
   SafeInterpreter = nullptr;
   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";
   }
 
   switch (InterpreterSel) {
   case AutoPick:
     if (!Interpreter) {
       InterpreterSel = RunJIT;
Interpreter = AbstractInterpreter::createLLC(
         InterpreterSel == RunLLCIA);
     break;
   case RunJIT:
     Interpreter =
         AbstractInterpreter::createJIT(getToolName(), Message, &ToolArgv);
     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)
     errs() << Message;
   else // Display informational messages on stdout instead of stderr
     outs() << Message;
 
   std::string Path = SafeInterpreterPath;
Error BugDriver::initializeExecutionEnvironment() {
   case RunLLC:
   case RunLLCIA:
     SafeToolArgs.push_back("--relocation-model=pic");
     SafeInterpreter = AbstractInterpreter::createLLC(
         Path.c_str(), Message, CCBinary, &SafeToolArgs, &CCToolArgv,
         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 "
               "\"safe\" backend right now!\n";
     break;
   }
   if (!SafeInterpreter) {
     outs() << Message << "\nExiting.\n";
     exit(1);
   }
 
-  cc = CC::create(Message, CCBinary, &CCToolArgv);
+  cc = CC::create(getToolName(), Message, CCBinary, &CCToolArgv);
   if (!cc) {
     outs() << Message << "\nExiting.\n";
     exit(1);
   }
 
   // If there was an error creating the selected interpreter, quit with error.
   if (Interpreter == nullptr)
     return make_error<StringError>("Failed to init execution environment",

tools/bugpoint/OptimizerDriver.cpp

 // without the threat of a buggy pass corrupting bugpoint (of course, bugpoint
 // may have its own bugs, but that's another story...).  It achieves this by
 // forking a copy of itself and having the child process do the optimizations.
 // If this client dies, we can always fork a new one.  :)
 //
 //===----------------------------------------------------------------------===//
 
 #include "BugDriver.h"
+#include "ToolRunner.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
bool BugDriver::runPasses(Module &Program,
   if (OS.has_error()) {
     errs() << "Error writing bitcode file: " << Temp->TmpName << "\n";
     OS.clear_error();
     return 1;
   }
 
   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";
   }
   if (tool.empty()) {
     errs() << "Cannot find `opt' in PATH!\n";
     return 1;
   }

tools/bugpoint/ToolRunner.h

const std::vector<std::string> *CCArgs)
       : CCPath(ccPath), RemoteClientPath(RemotePath) {
     if (CCArgs)
       ccArgs = *CCArgs;
   }
 
 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
   /// either a .s file, or a .c file, specified by FileType), with the specified
   /// arguments.  Standard input is specified with InputFile, and standard
   /// Output is captured to the specified OutputFile location.  The SharedLibs
   /// option specifies optional native shared objects that can be loaded into
   /// the program for execution.
public:
   createLLI(const char *Argv0, std::string &Message,
             const std::vector<std::string> *Args = nullptr);
 
   static AbstractInterpreter *
   createJIT(const char *Argv0, std::string &Message,
             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() {}
 
   /// compileProgram - Compile the specified program from bitcode to executable
   /// code.  This does not produce any output, it is only used when debugging
   /// the code generator.  It returns false if the code generator fails.
   virtual Error compileProgram(const std::string &Bitcode, unsigned Timeout = 0,
Expected<int> ExecuteProgram(
       const std::vector<std::string> &SharedLibs = std::vector<std::string>(),
       unsigned Timeout = 0, unsigned MemoryLimit = 0) override;
 
   Expected<CC::FileType> OutputCode(const std::string &Bitcode,
                                     std::string &OutFile, unsigned Timeout = 0,
                                     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

tools/bugpoint/ToolRunner.cpp

LLVM_DEBUG(errs() << "\nAbout to run:\t";
              << " " << LLIArgs[i];
              errs() << "\n";);
   return RunProgramWithTimeout(LLIPath, LLIArgs, InputFile, OutputFile,
                                OutputFile, Timeout, MemoryLimit);
 }
 
 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
   // this if ProgramPath contains at least one / character, indicating that it
   // 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);
-  }
-
-  Message = "Cannot find `lli' in executable directory!\n";
+  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;
   }
+}
 
 //===---------------------------------------------------------------------===//
 // Custom compiler command implementation of AbstractIntepreter interface
 //
 // Allows using a custom command for compiling the bitcode, thus allows, for
 // example, to compile a bitcode fragment without linking or executing, then
 // using a custom wrapper script to check for compiler errors.
 namespace {

 // delimiter.
 // Any other instances of the '\' character are removed.
 //
 // Example:
 // '\\' -> '\'
 // '\ ' -> ' '
 // '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;
   bool FoundPath = false;
 
   // first argument is the PATH.
   // Skip repeated whitespace, leading whitespace and trailing whitespace.
   for (std::size_t Pos = 0u; Pos <= CommandLine.size(); ++Pos) {
if (' ' == CommandLine[Pos] || CommandLine.size() == Pos) {
 
       Args.push_back(Token);
       Token.clear();
       continue;
     }
     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";
     return;
   }
   CmdPath = *Path;
 
   Message = "Found command in: " + CmdPath + "\n";
 }
 
 // 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;
 
   return new CustomCompiler(CmdPath, Args);
 }
 
 // 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;
 
   return new CustomExecutor(CmdPath, Args);
 }
 
 //===----------------------------------------------------------------------===//
 // LLC Implementation of AbstractIntepreter interface

 
 /// createLLC - Try to find the LLC executable
 ///
 LLC *AbstractInterpreter::createLLC(const char *Argv0, std::string &Message,
                                     const std::string &CCBinary,
                                     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);
 }
 
 //===---------------------------------------------------------------------===//
 // JIT Implementation of AbstractIntepreter interface
 //
 namespace {
 class JIT : public AbstractInterpreter {
   std::string LLIPath;               // The path to the LLI executable
return RunProgramWithTimeout(LLIPath, JITArgs, InputFile, OutputFile,
                                OutputFile, Timeout, MemoryLimit);
 }
 
 /// createJIT - Try to find the LLI executable
 ///
 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);
-  }
-
-  Message = "Cannot find `lli' in executable directory!\n";
+  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;
   }
+}
 
 //===---------------------------------------------------------------------===//
 // CC abstraction
 //
 
 static bool IsARMArchitecture(std::vector<StringRef> Args) {
   for (size_t I = 0; I < Args.size(); ++I) {
     if (!Args[I].equals_lower("-arch"))
LLVM_DEBUG(errs() << "\nAbout to run:\t";
              errs() << "\n";);
   if (RunProgramWithTimeout(CCPath, CCArgs, "", "", ""))
     return ProcessFailure(CCPath, CCArgs);
   return Error::success();
 }
 
 /// 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";
     return nullptr;
   }
 
   std::string RemoteClientPath;
   if (!RemoteClient.empty()) {