[bugpoint] Add options to support copying to remote host

[jrtc27]

Summary

We already have --remote-{client,host,port,user,extra-options} in order
to allow binaries to be run remotely via ssh. However, that bakes in the
assumption that "cd $PWD; ./$EXE" will work on the remote host, i.e.
that $PWD is a shared network directory and that the path to it is
identical on both hosts, which is normally not the case.

This adds --remote-copy, which takes the name of or path to an scp (or
compatible) program, mirroring --remote-client, and --remote-directory
as the location to which to copy the executable, which can also be used
on its own if you have a shared network directory but its path differs
between hosts.

[MaskRay]

Can you add some instructions to the summary how this feature is used?

llvm/tools/bugpoint/ToolRunner.h

 class LLC;
 
 //===---------------------------------------------------------------------===//
 // CC abstraction
 //
 class CC {
   std::string CCPath;              // The path to the cc executable.
   std::string RemoteClientPath;    // The path to the rsh / ssh executable.
+  std::string RemoteCopyPath;      // The path to the scp executable.
   std::vector<std::string> ccArgs; // CC-specific arguments.
-  CC(StringRef ccPath, StringRef RemotePath,
+  CC(StringRef ccPath, StringRef RemotePath, StringRef CopyPath,
      const std::vector<std::string> *CCArgs)
-      : CCPath(std::string(ccPath)), RemoteClientPath(std::string(RemotePath)) {
+      : CCPath(std::string(ccPath)), RemoteClientPath(std::string(RemotePath)),
+               RemoteCopyPath(std::string(CopyPath)) {
     if (CCArgs)
       ccArgs = *CCArgs;
   }
 
 public:
   enum FileType { AsmFile, ObjectFile, CFile };
 
   static CC *create(const char *Argv0, std::string &Message,

llvm/tools/bugpoint/ToolRunner.cpp

cl::opt<std::string> RemoteHost("remote-host",
                                 cl::desc("Remote execution (rsh/ssh) host"));
 
 cl::opt<std::string> RemotePort("remote-port",
                                 cl::desc("Remote execution (rsh/ssh) port"));
 
 cl::opt<std::string> RemoteUser("remote-user",
                                 cl::desc("Remote execution (rsh/ssh) user id"));
 
+cl::opt<std::string> RemoteDir("remote-directory",
+                               cl::desc("Remote execution (rsh/ssh) directory"));
+
 cl::opt<std::string>
     RemoteExtra("remote-extra-options",
                 cl::desc("Remote execution (rsh/ssh) extra options"));
+
+cl::opt<std::string>
+    RemoteCopy("remote-copy",
+               cl::desc("Remote execution copy client (scp)"));
 }
 
 /// RunProgramWithTimeout - This function provides an alternate interface
 /// to the sys::Program::ExecuteAndWait interface.
 /// @see sys::Program::ExecuteAndWait
 static int RunProgramWithTimeout(StringRef ProgramPath,
                                  ArrayRef<StringRef> Args, StringRef StdInFile,
                                  StringRef StdOutFile, StringRef StdErrFile,
Expected<int> CC::ExecuteProgram(const std::string &ProgramFile,
   outs().flush();
   LLVM_DEBUG(errs() << "\nAbout to run:\t";
              for (unsigned i = 0, e = CCArgs.size(); i != e; ++i) errs()
              << " " << CCArgs[i];
              errs() << "\n";);
   if (RunProgramWithTimeout(CCPath, CCArgs, "", "", ""))
     return ProcessFailure(CCPath, CCArgs);
 
+  FileRemover OutputBinaryRemover(OutputBinary.str(), !SaveTemps);
+
   std::vector<StringRef> ProgramArgs;
 
   // Declared here so that the destructor only runs after
   // ProgramArgs is used.
   std::string Exec;
 
   if (RemoteClientPath.empty())
     ProgramArgs.push_back(OutputBinary);
   else {
+    const char *Dir = getenv("PWD");
+
+    if (!RemoteCopy.empty()) {
+      // Declared here so that the destructor only runs after
+      // RemoteCopyArgs is used.
+      std::string CopyTarget;
+      std::vector<StringRef> RemoteCopyArgs;
+      RemoteCopyArgs.push_back(RemoteCopyPath);
+
+      if (!RemotePort.empty()) {
+        ProgramArgs.push_back("-P");
+        ProgramArgs.push_back(RemotePort);
+      }
+
+      RemoteCopyArgs.push_back(OutputBinary);
+
+      CopyTarget = "";
+      if (!RemoteUser.empty()) {
+        CopyTarget += RemoteUser;
+        CopyTarget += "@";
+      }
+      CopyTarget += RemoteHost;
+      CopyTarget += ":";
+      CopyTarget += RemoteDir;
+      Dir = RemoteDir.c_str();
+      CopyTarget += "/";
+      RemoteCopyArgs.push_back(CopyTarget);
+
+      outs() << "<copy>";
+      outs().flush();
+      LLVM_DEBUG(
+          errs() << "\nAbout to run:\t";
+          for (unsigned i = 0, e = RemoteCopyArgs.size(); i != e; ++i) errs()
+          << " " << RemoteCopyArgs[i];
+          errs() << "\n";);
+
+      if (RunProgramWithTimeout(RemoteCopyPath, RemoteCopyArgs, "", "", ""))
+        return ProcessFailure(RemoteCopyPath, RemoteCopyArgs);
+    } else if (!RemoteDir.empty())
+      Dir = RemoteDir.c_str();
+
     ProgramArgs.push_back(RemoteClientPath);
     ProgramArgs.push_back(RemoteHost);
     if (!RemoteUser.empty()) {
       ProgramArgs.push_back("-l");
       ProgramArgs.push_back(RemoteUser);
     }
     if (!RemotePort.empty()) {
       ProgramArgs.push_back("-p");
       ProgramArgs.push_back(RemotePort);
     }
     if (!RemoteExtra.empty()) {
       ProgramArgs.push_back(RemoteExtra);
     }
 
     // Full path to the binary. We need to cd to the exec directory because
     // there is a dylib there that the exec expects to find in the CWD
-    char *env_pwd = getenv("PWD");
     Exec = "cd ";
-    Exec += env_pwd;
+    Exec += Dir;
     Exec += "; ./";
     Exec += OutputBinary.c_str();
     ProgramArgs.push_back(Exec);
   }
 
   // Add optional parameters to the running program from Argv
   for (unsigned i = 0, e = Args.size(); i != e; ++i)
     ProgramArgs.push_back(Args[i]);
 
   // Now that we have a binary, run it!
   outs() << "<program>";
   outs().flush();
   LLVM_DEBUG(
       errs() << "\nAbout to run:\t";
       for (unsigned i = 0, e = ProgramArgs.size(); i != e; ++i) errs()
       << " " << ProgramArgs[i];
       errs() << "\n";);
 
-  FileRemover OutputBinaryRemover(OutputBinary.str(), !SaveTemps);
-
   if (RemoteClientPath.empty()) {
     LLVM_DEBUG(errs() << "<run locally>");
     std::string Error;
     int ExitCode = RunProgramWithTimeout(OutputBinary.str(), ProgramArgs,
                                          InputFile, OutputFile, OutputFile,
                                          Timeout, MemoryLimit, &Error);
     // Treat a signal (usually SIGSEGV) or timeout as part of the program output
     // so that crash-causing miscompilation is handled seamlessly.
if (!RemoteClient.empty()) {
     if (!Path) {
       Message = "Cannot find `" + RemoteClient + "' in PATH: " +
                 Path.getError().message() + "\n";
       return nullptr;
     }
     RemoteClientPath = *Path;
   }
 
+  std::string RemoteCopyPath;
+  if (!RemoteCopy.empty()) {
+    auto Path = sys::findProgramByName(RemoteCopy);
+    if (!Path) {
+      Message = "Cannot find `" + RemoteCopy + "' in PATH: " +
+                Path.getError().message() + "\n";
+      return nullptr;
+    }
+    RemoteCopyPath = *Path;
+  }
+
   Message = "Found CC: " + *CCPath + "\n";
-  return new CC(*CCPath, RemoteClientPath, Args);
+  return new CC(*CCPath, RemoteClientPath, RemoteCopyPath, Args);
 }