tools/bugpoint/ToolRunner.cpp

   1 //===-- ToolRunner.cpp ----------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the interfaces described in the ToolRunner.h file.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "toolrunner"
  15 #include "ToolRunner.h"
  16 #include "llvm/System/Program.h"
  17 #include "llvm/Support/CommandLine.h"
  18 #include "llvm/Support/Debug.h"
  19 #include "llvm/Support/FileUtilities.h"
  20 #include "llvm/Support/raw_ostream.h"
  21 #include "llvm/Config/config.h"   // for HAVE_LINK_R
  22 #include <fstream>
  23 #include <sstream>
  24 using namespace llvm;
  25
  26 namespace llvm {
  27   cl::opt<bool>
  28   SaveTemps("save-temps", cl::init(false), cl::desc("Save temporary files"));
  29 }
  30
  31 namespace {
  32   cl::opt<std::string>
  33   RemoteClient("remote-client",
  34                cl::desc("Remote execution client (rsh/ssh)"));
  35
  36   cl::opt<std::string>
  37   RemoteHost("remote-host",
  38              cl::desc("Remote execution (rsh/ssh) host"));
  39
  40   cl::opt<std::string>
  41   RemotePort("remote-port",
  42              cl::desc("Remote execution (rsh/ssh) port"));
  43
  44   cl::opt<std::string>
  45   RemoteUser("remote-user",
  46              cl::desc("Remote execution (rsh/ssh) user id"));
  47
  48   cl::opt<std::string>
  49   RemoteExtra("remote-extra-options",
  50           cl::desc("Remote execution (rsh/ssh) extra options"));
  51 }
  52
  53 ToolExecutionError::~ToolExecutionError() throw() { }
  54
  55 /// RunProgramWithTimeout - This function provides an alternate interface
  56 /// to the sys::Program::ExecuteAndWait interface.
  57 /// @see sys:Program::ExecuteAndWait
  58 static int RunProgramWithTimeout(const sys::Path &ProgramPath,
  59                                  const char **Args,
  60                                  const sys::Path &StdInFile,
  61                                  const sys::Path &StdOutFile,
  62                                  const sys::Path &StdErrFile,
  63                                  unsigned NumSeconds = 0,
  64                                  unsigned MemoryLimit = 0) {
  65   const sys::Path* redirects[3];
  66   redirects[0] = &StdInFile;
  67   redirects[1] = &StdOutFile;
  68   redirects[2] = &StdErrFile;
  69
  70 #if 0 // For debug purposes
  71   {
  72     errs() << "RUN:";
  73     for (unsigned i = 0; Args[i]; ++i)
  74       errs() << " " << Args[i];
  75     errs() << "\n";
  76   }
  77 #endif
  78
  79   return
  80     sys::Program::ExecuteAndWait(ProgramPath, Args, 0, redirects,
  81                                  NumSeconds, MemoryLimit);
  82 }
  83
  84 /// RunProgramRemotelyWithTimeout - This function runs the given program
  85 /// remotely using the given remote client and the sys::Program::ExecuteAndWait.
  86 /// Returns the remote program exit code or reports a remote client error if it
  87 /// fails. Remote client is required to return 255 if it failed or program exit
  88 /// code otherwise.
  89 /// @see sys:Program::ExecuteAndWait
  90 static int RunProgramRemotelyWithTimeout(const sys::Path &RemoteClientPath,
  91                                          const char **Args,
  92                                          const sys::Path &StdInFile,
  93                                          const sys::Path &StdOutFile,
  94                                          const sys::Path &StdErrFile,
  95                                          unsigned NumSeconds = 0,
  96                                          unsigned MemoryLimit = 0) {
  97   const sys::Path* redirects[3];
  98   redirects[0] = &StdInFile;
  99   redirects[1] = &StdOutFile;
 100   redirects[2] = &StdErrFile;
 101
 102 #if 0 // For debug purposes
 103   {
 104     errs() << "RUN:";
 105     for (unsigned i = 0; Args[i]; ++i)
 106       errs() << " " << Args[i];
 107     errs() << "\n";
 108   }
 109 #endif
 110
 111   // Run the program remotely with the remote client
 112   int ReturnCode = sys::Program::ExecuteAndWait(RemoteClientPath, Args,
 113                                  0, redirects, NumSeconds, MemoryLimit);
 114
 115   // Has the remote client fail?
 116   if (255 == ReturnCode) {
 117     std::ostringstream OS;
 118     OS << "\nError running remote client:\n ";
 119     for (const char **Arg = Args; *Arg; ++Arg)
 120       OS << " " << *Arg;
 121     OS << "\n";
 122
 123     // The error message is in the output file, let's print it out from there.
 124     std::ifstream ErrorFile(StdOutFile.c_str());
 125     if (ErrorFile) {
 126       std::copy(std::istreambuf_iterator<char>(ErrorFile),
 127                 std::istreambuf_iterator<char>(),
 128                 std::ostreambuf_iterator<char>(OS));
 129       ErrorFile.close();
 130     }
 131
 132     throw ToolExecutionError(OS.str());
 133   }
 134
 135   return ReturnCode;
 136 }
 137
 138 static void ProcessFailure(sys::Path ProgPath, const char** Args) {
 139   std::ostringstream OS;
 140   OS << "\nError running tool:\n ";
 141   for (const char **Arg = Args; *Arg; ++Arg)
 142     OS << " " << *Arg;
 143   OS << "\n";
 144
 145   // Rerun the compiler, capturing any error messages to print them.
 146   sys::Path ErrorFilename("bugpoint.program_error_messages");
 147   std::string ErrMsg;
 148   if (ErrorFilename.makeUnique(true, &ErrMsg)) {
 149     errs() << "Error making unique filename: " << ErrMsg << "\n";
 150     exit(1);
 151   }
 152   RunProgramWithTimeout(ProgPath, Args, sys::Path(""), ErrorFilename,
 153                         ErrorFilename); // FIXME: check return code ?
 154
 155   // Print out the error messages generated by GCC if possible...
 156   std::ifstream ErrorFile(ErrorFilename.c_str());
 157   if (ErrorFile) {
 158     std::copy(std::istreambuf_iterator<char>(ErrorFile),
 159               std::istreambuf_iterator<char>(),
 160               std::ostreambuf_iterator<char>(OS));
 161     ErrorFile.close();
 162   }
 163
 164   ErrorFilename.eraseFromDisk();
 165   throw ToolExecutionError(OS.str());
 166 }
 167
 168 //===---------------------------------------------------------------------===//
 169 // LLI Implementation of AbstractIntepreter interface
 170 //
 171 namespace {
 172   class LLI : public AbstractInterpreter {
 173     std::string LLIPath;          // The path to the LLI executable
 174     std::vector<std::string> ToolArgs; // Args to pass to LLI
 175   public:
 176     LLI(const std::string &Path, const std::vector<std::string> *Args)
 177       : LLIPath(Path) {
 178       ToolArgs.clear ();
 179       if (Args) { ToolArgs = *Args; }
 180     }
 181
 182     virtual int ExecuteProgram(const std::string &Bitcode,
 183                                const std::vector<std::string> &Args,
 184                                const std::string &InputFile,
 185                                const std::string &OutputFile,
 186                                const std::vector<std::string> &GCCArgs,
 187                                const std::vector<std::string> &SharedLibs =
 188                                std::vector<std::string>(),
 189                                unsigned Timeout = 0,
 190                                unsigned MemoryLimit = 0);
 191   };
 192 }
 193
 194 int LLI::ExecuteProgram(const std::string &Bitcode,
 195                         const std::vector<std::string> &Args,
 196                         const std::string &InputFile,
 197                         const std::string &OutputFile,
 198                         const std::vector<std::string> &GCCArgs,
 199                         const std::vector<std::string> &SharedLibs,
 200                         unsigned Timeout,
 201                         unsigned MemoryLimit) {
 202   if (!SharedLibs.empty())
 203     throw ToolExecutionError("LLI currently does not support "
 204                              "loading shared libraries.");
 205
 206   std::vector<const char*> LLIArgs;
 207   LLIArgs.push_back(LLIPath.c_str());
 208   LLIArgs.push_back("-force-interpreter=true");
 209
 210   // Add any extra LLI args.
 211   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 212     LLIArgs.push_back(ToolArgs[i].c_str());
 213
 214   LLIArgs.push_back(Bitcode.c_str());
 215   // Add optional parameters to the running program from Argv
 216   for (unsigned i=0, e = Args.size(); i != e; ++i)
 217     LLIArgs.push_back(Args[i].c_str());
 218   LLIArgs.push_back(0);
 219
 220   outs() << "<lli>"; outs().flush();
 221   DEBUG(errs() << "\nAbout to run:\t";
 222         for (unsigned i=0, e = LLIArgs.size()-1; i != e; ++i)
 223           errs() << " " << LLIArgs[i];
 224         errs() << "\n";
 225         );
 226   return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
 227       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 228       Timeout, MemoryLimit);
 229 }
 230
 231 // LLI create method - Try to find the LLI executable
 232 AbstractInterpreter *AbstractInterpreter::createLLI(const char *Argv0,
 233                                                     std::string &Message,
 234                                      const std::vector<std::string> *ToolArgs) {
 235   std::string LLIPath =
 236     FindExecutable("lli", Argv0, (void *)(intptr_t)&createLLI).str();
 237   if (!LLIPath.empty()) {
 238     Message = "Found lli: " + LLIPath + "\n";
 239     return new LLI(LLIPath, ToolArgs);
 240   }
 241
 242   Message = "Cannot find `lli' in executable directory or PATH!\n";
 243   return 0;
 244 }
 245
 246 //===---------------------------------------------------------------------===//
 247 // Custom execution command implementation of AbstractIntepreter interface
 248 //
 249 // Allows using a custom command for executing the bitcode, thus allows,
 250 // for example, to invoke a cross compiler for code generation followed by
 251 // a simulator that executes the generated binary.
 252 namespace {
 253   class CustomExecutor : public AbstractInterpreter {
 254     std::string ExecutionCommand;
 255     std::vector<std::string> ExecutorArgs;
 256   public:
 257     CustomExecutor(
 258       const std::string &ExecutionCmd, std::vector<std::string> ExecArgs) :
 259       ExecutionCommand(ExecutionCmd), ExecutorArgs(ExecArgs) {}
 260
 261     virtual int ExecuteProgram(const std::string &Bitcode,
 262                                const std::vector<std::string> &Args,
 263                                const std::string &InputFile,
 264                                const std::string &OutputFile,
 265                                const std::vector<std::string> &GCCArgs,
 266                                const std::vector<std::string> &SharedLibs =
 267                                std::vector<std::string>(),
 268                                unsigned Timeout = 0,
 269                                unsigned MemoryLimit = 0);
 270   };
 271 }
 272
 273 int CustomExecutor::ExecuteProgram(const std::string &Bitcode,
 274                         const std::vector<std::string> &Args,
 275                         const std::string &InputFile,
 276                         const std::string &OutputFile,
 277                         const std::vector<std::string> &GCCArgs,
 278                         const std::vector<std::string> &SharedLibs,
 279                         unsigned Timeout,
 280                         unsigned MemoryLimit) {
 281
 282   std::vector<const char*> ProgramArgs;
 283   ProgramArgs.push_back(ExecutionCommand.c_str());
 284
 285   for (std::size_t i = 0; i < ExecutorArgs.size(); ++i)
 286     ProgramArgs.push_back(ExecutorArgs.at(i).c_str());
 287   ProgramArgs.push_back(Bitcode.c_str());
 288   ProgramArgs.push_back(0);
 289
 290   // Add optional parameters to the running program from Argv
 291   for (unsigned i=0, e = Args.size(); i != e; ++i)
 292     ProgramArgs.push_back(Args[i].c_str());
 293
 294   return RunProgramWithTimeout(
 295     sys::Path(ExecutionCommand),
 296     &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 297     sys::Path(OutputFile), Timeout, MemoryLimit);
 298 }
 299
 300 // Custom execution environment create method, takes the execution command
 301 // as arguments
 302 AbstractInterpreter *AbstractInterpreter::createCustom(
 303                     std::string &Message,
 304                     const std::string &ExecCommandLine) {
 305
 306   std::string Command = "";
 307   std::vector<std::string> Args;
 308   std::string delimiters = " ";
 309
 310   // Tokenize the ExecCommandLine to the command and the args to allow
 311   // defining a full command line as the command instead of just the
 312   // executed program. We cannot just pass the whole string after the command
 313   // as a single argument because then program sees only a single
 314   // command line argument (with spaces in it: "foo bar" instead
 315   // of "foo" and "bar").
 316
 317   // code borrowed from:
 318   // http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html
 319   std::string::size_type lastPos =
 320     ExecCommandLine.find_first_not_of(delimiters, 0);
 321   std::string::size_type pos =
 322     ExecCommandLine.find_first_of(delimiters, lastPos);
 323
 324   while (std::string::npos != pos || std::string::npos != lastPos) {
 325     std::string token = ExecCommandLine.substr(lastPos, pos - lastPos);
 326     if (Command == "")
 327        Command = token;
 328     else
 329        Args.push_back(token);
 330     // Skip delimiters.  Note the "not_of"
 331     lastPos = ExecCommandLine.find_first_not_of(delimiters, pos);
 332     // Find next "non-delimiter"
 333     pos = ExecCommandLine.find_first_of(delimiters, lastPos);
 334   }
 335
 336   std::string CmdPath = sys::Program::FindProgramByName(Command).str();
 337   if (CmdPath.empty()) {
 338     Message =
 339       std::string("Cannot find '") + Command +
 340       "' in executable directory or PATH!\n";
 341     return 0;
 342   }
 343
 344   Message = "Found command in: " + CmdPath + "\n";
 345
 346   return new CustomExecutor(CmdPath, Args);
 347 }
 348
 349 //===----------------------------------------------------------------------===//
 350 // LLC Implementation of AbstractIntepreter interface
 351 //
 352 GCC::FileType LLC::OutputCode(const std::string &Bitcode,
 353                               sys::Path &OutputAsmFile) {
 354   sys::Path uniqueFile(Bitcode+".llc.s");
 355   std::string ErrMsg;
 356   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 357     errs() << "Error making unique filename: " << ErrMsg << "\n";
 358     exit(1);
 359   }
 360   OutputAsmFile = uniqueFile;
 361   std::vector<const char *> LLCArgs;
 362   LLCArgs.push_back (LLCPath.c_str());
 363
 364   // Add any extra LLC args.
 365   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 366     LLCArgs.push_back(ToolArgs[i].c_str());
 367
 368   LLCArgs.push_back ("-o");
 369   LLCArgs.push_back (OutputAsmFile.c_str()); // Output to the Asm file
 370   LLCArgs.push_back (Bitcode.c_str());      // This is the input bitcode
 371   LLCArgs.push_back (0);
 372
 373   outs() << "<llc>"; outs().flush();
 374   DEBUG(errs() << "\nAbout to run:\t";
 375         for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
 376           errs() << " " << LLCArgs[i];
 377         errs() << "\n";
 378         );
 379   if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
 380                             sys::Path(), sys::Path(), sys::Path()))
 381     ProcessFailure(sys::Path(LLCPath), &LLCArgs[0]);
 382
 383   return GCC::AsmFile;
 384 }
 385
 386 void LLC::compileProgram(const std::string &Bitcode) {
 387   sys::Path OutputAsmFile;
 388   OutputCode(Bitcode, OutputAsmFile);
 389   OutputAsmFile.eraseFromDisk();
 390 }
 391
 392 int LLC::ExecuteProgram(const std::string &Bitcode,
 393                         const std::vector<std::string> &Args,
 394                         const std::string &InputFile,
 395                         const std::string &OutputFile,
 396                         const std::vector<std::string> &ArgsForGCC,
 397                         const std::vector<std::string> &SharedLibs,
 398                         unsigned Timeout,
 399                         unsigned MemoryLimit) {
 400
 401   sys::Path OutputAsmFile;
 402   OutputCode(Bitcode, OutputAsmFile);
 403   FileRemover OutFileRemover(OutputAsmFile, !SaveTemps);
 404
 405   std::vector<std::string> GCCArgs(ArgsForGCC);
 406   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 407   GCCArgs.insert(GCCArgs.end(), gccArgs.begin(), gccArgs.end());
 408
 409   // Assuming LLC worked, compile the result with GCC and run it.
 410   return gcc->ExecuteProgram(OutputAsmFile.str(), Args, GCC::AsmFile,
 411                              InputFile, OutputFile, GCCArgs,
 412                              Timeout, MemoryLimit);
 413 }
 414
 415 /// createLLC - Try to find the LLC executable
 416 ///
 417 LLC *AbstractInterpreter::createLLC(const char *Argv0,
 418                                     std::string &Message,
 419                                     const std::vector<std::string> *Args,
 420                                     const std::vector<std::string> *GCCArgs) {
 421   std::string LLCPath =
 422     FindExecutable("llc", Argv0, (void *)(intptr_t)&createLLC).str();
 423   if (LLCPath.empty()) {
 424     Message = "Cannot find `llc' in executable directory or PATH!\n";
 425     return 0;
 426   }
 427
 428   Message = "Found llc: " + LLCPath + "\n";
 429   GCC *gcc = GCC::create(Message, GCCArgs);
 430   if (!gcc) {
 431     errs() << Message << "\n";
 432     exit(1);
 433   }
 434   return new LLC(LLCPath, gcc, Args, GCCArgs);
 435 }
 436
 437 //===---------------------------------------------------------------------===//
 438 // JIT Implementation of AbstractIntepreter interface
 439 //
 440 namespace {
 441   class JIT : public AbstractInterpreter {
 442     std::string LLIPath;          // The path to the LLI executable
 443     std::vector<std::string> ToolArgs; // Args to pass to LLI
 444   public:
 445     JIT(const std::string &Path, const std::vector<std::string> *Args)
 446       : LLIPath(Path) {
 447       ToolArgs.clear ();
 448       if (Args) { ToolArgs = *Args; }
 449     }
 450
 451     virtual int ExecuteProgram(const std::string &Bitcode,
 452                                const std::vector<std::string> &Args,
 453                                const std::string &InputFile,
 454                                const std::string &OutputFile,
 455                                const std::vector<std::string> &GCCArgs =
 456                                  std::vector<std::string>(),
 457                                const std::vector<std::string> &SharedLibs =
 458                                  std::vector<std::string>(),
 459                                unsigned Timeout =0,
 460                                unsigned MemoryLimit =0);
 461   };
 462 }
 463
 464 int JIT::ExecuteProgram(const std::string &Bitcode,
 465                         const std::vector<std::string> &Args,
 466                         const std::string &InputFile,
 467                         const std::string &OutputFile,
 468                         const std::vector<std::string> &GCCArgs,
 469                         const std::vector<std::string> &SharedLibs,
 470                         unsigned Timeout,
 471                         unsigned MemoryLimit) {
 472   // Construct a vector of parameters, incorporating those from the command-line
 473   std::vector<const char*> JITArgs;
 474   JITArgs.push_back(LLIPath.c_str());
 475   JITArgs.push_back("-force-interpreter=false");
 476
 477   // Add any extra LLI args.
 478   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 479     JITArgs.push_back(ToolArgs[i].c_str());
 480
 481   for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
 482     JITArgs.push_back("-load");
 483     JITArgs.push_back(SharedLibs[i].c_str());
 484   }
 485   JITArgs.push_back(Bitcode.c_str());
 486   // Add optional parameters to the running program from Argv
 487   for (unsigned i=0, e = Args.size(); i != e; ++i)
 488     JITArgs.push_back(Args[i].c_str());
 489   JITArgs.push_back(0);
 490
 491   outs() << "<jit>"; outs().flush();
 492   DEBUG(errs() << "\nAbout to run:\t";
 493         for (unsigned i=0, e = JITArgs.size()-1; i != e; ++i)
 494           errs() << " " << JITArgs[i];
 495         errs() << "\n";
 496         );
 497   DEBUG(errs() << "\nSending output to " << OutputFile << "\n");
 498   return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
 499       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 500       Timeout, MemoryLimit);
 501 }
 502
 503 /// createJIT - Try to find the LLI executable
 504 ///
 505 AbstractInterpreter *AbstractInterpreter::createJIT(const char *Argv0,
 506                    std::string &Message, const std::vector<std::string> *Args) {
 507   std::string LLIPath =
 508     FindExecutable("lli", Argv0, (void *)(intptr_t)&createJIT).str();
 509   if (!LLIPath.empty()) {
 510     Message = "Found lli: " + LLIPath + "\n";
 511     return new JIT(LLIPath, Args);
 512   }
 513
 514   Message = "Cannot find `lli' in executable directory or PATH!\n";
 515   return 0;
 516 }
 517
 518 GCC::FileType CBE::OutputCode(const std::string &Bitcode,
 519                               sys::Path &OutputCFile) {
 520   sys::Path uniqueFile(Bitcode+".cbe.c");
 521   std::string ErrMsg;
 522   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 523     errs() << "Error making unique filename: " << ErrMsg << "\n";
 524     exit(1);
 525   }
 526   OutputCFile = uniqueFile;
 527   std::vector<const char *> LLCArgs;
 528   LLCArgs.push_back (LLCPath.c_str());
 529
 530   // Add any extra LLC args.
 531   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 532     LLCArgs.push_back(ToolArgs[i].c_str());
 533
 534   LLCArgs.push_back ("-o");
 535   LLCArgs.push_back (OutputCFile.c_str());   // Output to the C file
 536   LLCArgs.push_back ("-march=c");            // Output C language
 537   LLCArgs.push_back ("-f");                  // Overwrite as necessary...
 538   LLCArgs.push_back (Bitcode.c_str());      // This is the input bitcode
 539   LLCArgs.push_back (0);
 540
 541   outs() << "<cbe>"; outs().flush();
 542   DEBUG(errs() << "\nAbout to run:\t";
 543         for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
 544           errs() << " " << LLCArgs[i];
 545         errs() << "\n";
 546         );
 547   if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
 548                             sys::Path()))
 549     ProcessFailure(LLCPath, &LLCArgs[0]);
 550   return GCC::CFile;
 551 }
 552
 553 void CBE::compileProgram(const std::string &Bitcode) {
 554   sys::Path OutputCFile;
 555   OutputCode(Bitcode, OutputCFile);
 556   OutputCFile.eraseFromDisk();
 557 }
 558
 559 int CBE::ExecuteProgram(const std::string &Bitcode,
 560                         const std::vector<std::string> &Args,
 561                         const std::string &InputFile,
 562                         const std::string &OutputFile,
 563                         const std::vector<std::string> &ArgsForGCC,
 564                         const std::vector<std::string> &SharedLibs,
 565                         unsigned Timeout,
 566                         unsigned MemoryLimit) {
 567   sys::Path OutputCFile;
 568   OutputCode(Bitcode, OutputCFile);
 569
 570   FileRemover CFileRemove(OutputCFile, !SaveTemps);
 571
 572   std::vector<std::string> GCCArgs(ArgsForGCC);
 573   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 574
 575   return gcc->ExecuteProgram(OutputCFile.str(), Args, GCC::CFile,
 576                              InputFile, OutputFile, GCCArgs,
 577                              Timeout, MemoryLimit);
 578 }
 579
 580 /// createCBE - Try to find the 'llc' executable
 581 ///
 582 CBE *AbstractInterpreter::createCBE(const char *Argv0,
 583                                     std::string &Message,
 584                                     const std::vector<std::string> *Args,
 585                                     const std::vector<std::string> *GCCArgs) {
 586   sys::Path LLCPath =
 587     FindExecutable("llc", Argv0, (void *)(intptr_t)&createCBE);
 588   if (LLCPath.isEmpty()) {
 589     Message =
 590       "Cannot find `llc' in executable directory or PATH!\n";
 591     return 0;
 592   }
 593
 594   Message = "Found llc: " + LLCPath.str() + "\n";
 595   GCC *gcc = GCC::create(Message, GCCArgs);
 596   if (!gcc) {
 597     errs() << Message << "\n";
 598     exit(1);
 599   }
 600   return new CBE(LLCPath, gcc, Args);
 601 }
 602
 603 //===---------------------------------------------------------------------===//
 604 // GCC abstraction
 605 //
 606
 607 static bool
 608 IsARMArchitecture(std::vector<std::string> Args)
 609 {
 610   for (std::vector<std::string>::const_iterator
 611          I = Args.begin(), E = Args.end(); I != E; ++I) {
 612     StringRef S(*I);
 613     if (!S.equals_lower("-arch")) {
 614       ++I;
 615       if (I != E && !S.substr(0, strlen("arm")).equals_lower("arm")) {
 616         return true;
 617       }
 618     }
 619   }
 620
 621   return false;
 622 }
 623
 624 int GCC::ExecuteProgram(const std::string &ProgramFile,
 625                         const std::vector<std::string> &Args,
 626                         FileType fileType,
 627                         const std::string &InputFile,
 628                         const std::string &OutputFile,
 629                         const std::vector<std::string> &ArgsForGCC,
 630                         unsigned Timeout,
 631                         unsigned MemoryLimit) {
 632   std::vector<const char*> GCCArgs;
 633
 634   GCCArgs.push_back(GCCPath.c_str());
 635
 636   for (std::vector<std::string>::const_iterator
 637          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 638     GCCArgs.push_back(I->c_str());
 639
 640   // Specify -x explicitly in case the extension is wonky
 641   GCCArgs.push_back("-x");
 642   if (fileType == CFile) {
 643     GCCArgs.push_back("c");
 644     GCCArgs.push_back("-fno-strict-aliasing");
 645   } else {
 646     GCCArgs.push_back("assembler");
 647
 648     // For ARM architectures we don't want this flag. bugpoint isn't
 649     // explicitly told what architecture it is working on, so we get
 650     // it from gcc flags
 651     if ((TargetTriple.getOS() == Triple::Darwin) &&
 652         !IsARMArchitecture(ArgsForGCC))
 653       GCCArgs.push_back("-force_cpusubtype_ALL");
 654   }
 655   GCCArgs.push_back(ProgramFile.c_str());  // Specify the input filename...
 656   GCCArgs.push_back("-x");
 657   GCCArgs.push_back("none");
 658   GCCArgs.push_back("-o");
 659   sys::Path OutputBinary (ProgramFile+".gcc.exe");
 660   std::string ErrMsg;
 661   if (OutputBinary.makeUnique(true, &ErrMsg)) {
 662     errs() << "Error making unique filename: " << ErrMsg << "\n";
 663     exit(1);
 664   }
 665   GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
 666
 667   // Add any arguments intended for GCC. We locate them here because this is
 668   // most likely -L and -l options that need to come before other libraries but
 669   // after the source. Other options won't be sensitive to placement on the
 670   // command line, so this should be safe.
 671   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 672     GCCArgs.push_back(ArgsForGCC[i].c_str());
 673
 674   GCCArgs.push_back("-lm");                // Hard-code the math library...
 675   GCCArgs.push_back("-O2");                // Optimize the program a bit...
 676 #if defined (HAVE_LINK_R)
 677   GCCArgs.push_back("-Wl,-R.");            // Search this dir for .so files
 678 #endif
 679   if (TargetTriple.getArch() == Triple::sparc)
 680     GCCArgs.push_back("-mcpu=v9");
 681   GCCArgs.push_back(0);                    // NULL terminator
 682
 683   outs() << "<gcc>"; outs().flush();
 684   DEBUG(errs() << "\nAbout to run:\t";
 685         for (unsigned i=0, e = GCCArgs.size()-1; i != e; ++i)
 686           errs() << " " << GCCArgs[i];
 687         errs() << "\n";
 688         );
 689   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 690         sys::Path())) {
 691     ProcessFailure(GCCPath, &GCCArgs[0]);
 692     exit(1);
 693   }
 694
 695   std::vector<const char*> ProgramArgs;
 696
 697   if (RemoteClientPath.isEmpty())
 698     ProgramArgs.push_back(OutputBinary.c_str());
 699   else {
 700     ProgramArgs.push_back(RemoteClientPath.c_str());
 701     ProgramArgs.push_back(RemoteHost.c_str());
 702     if (!RemoteUser.empty()) {
 703       ProgramArgs.push_back("-l");
 704       ProgramArgs.push_back(RemoteUser.c_str());
 705     }
 706     if (!RemotePort.empty()) {
 707       ProgramArgs.push_back("-p");
 708       ProgramArgs.push_back(RemotePort.c_str());
 709     }
 710     if (!RemoteExtra.empty()) {
 711       ProgramArgs.push_back(RemoteExtra.c_str());
 712     }
 713
 714     // Full path to the binary. We need to cd to the exec directory because
 715     // there is a dylib there that the exec expects to find in the CWD
 716     char* env_pwd = getenv("PWD");
 717     std::string Exec = "cd ";
 718     Exec += env_pwd;
 719     Exec += "; ./";
 720     Exec += OutputBinary.c_str();
 721     ProgramArgs.push_back(Exec.c_str());
 722   }
 723
 724   // Add optional parameters to the running program from Argv
 725   for (unsigned i=0, e = Args.size(); i != e; ++i)
 726     ProgramArgs.push_back(Args[i].c_str());
 727   ProgramArgs.push_back(0);                // NULL terminator
 728
 729   // Now that we have a binary, run it!
 730   outs() << "<program>"; outs().flush();
 731   DEBUG(errs() << "\nAbout to run:\t";
 732         for (unsigned i=0, e = ProgramArgs.size()-1; i != e; ++i)
 733           errs() << " " << ProgramArgs[i];
 734         errs() << "\n";
 735         );
 736
 737   FileRemover OutputBinaryRemover(OutputBinary, !SaveTemps);
 738
 739   if (RemoteClientPath.isEmpty()) {
 740     DEBUG(errs() << "<run locally>";);
 741     return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
 742         sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 743         Timeout, MemoryLimit);
 744   } else {
 745     outs() << "<run remotely>"; outs().flush();
 746     return RunProgramRemotelyWithTimeout(sys::Path(RemoteClientPath),
 747         &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 748         sys::Path(OutputFile), Timeout, MemoryLimit);
 749   }
 750 }
 751
 752 int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType,
 753                           std::string &OutputFile,
 754                           const std::vector<std::string> &ArgsForGCC) {
 755   sys::Path uniqueFilename(InputFile+LTDL_SHLIB_EXT);
 756   std::string ErrMsg;
 757   if (uniqueFilename.makeUnique(true, &ErrMsg)) {
 758     errs() << "Error making unique filename: " << ErrMsg << "\n";
 759     exit(1);
 760   }
 761   OutputFile = uniqueFilename.str();
 762
 763   std::vector<const char*> GCCArgs;
 764
 765   GCCArgs.push_back(GCCPath.c_str());
 766
 767   for (std::vector<std::string>::const_iterator
 768          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 769     GCCArgs.push_back(I->c_str());
 770
 771   // Compile the C/asm file into a shared object
 772   GCCArgs.push_back("-x");
 773   GCCArgs.push_back(fileType == AsmFile ? "assembler" : "c");
 774   GCCArgs.push_back("-fno-strict-aliasing");
 775   GCCArgs.push_back(InputFile.c_str());   // Specify the input filename.
 776   GCCArgs.push_back("-x");
 777   GCCArgs.push_back("none");
 778   if (TargetTriple.getArch() == Triple::sparc)
 779     GCCArgs.push_back("-G");       // Compile a shared library, `-G' for Sparc
 780   else if (TargetTriple.getOS() == Triple::Darwin) {
 781     // link all source files into a single module in data segment, rather than
 782     // generating blocks. dynamic_lookup requires that you set
 783     // MACOSX_DEPLOYMENT_TARGET=10.3 in your env.  FIXME: it would be better for
 784     // bugpoint to just pass that in the environment of GCC.
 785     GCCArgs.push_back("-single_module");
 786     GCCArgs.push_back("-dynamiclib");   // `-dynamiclib' for MacOS X/PowerPC
 787     GCCArgs.push_back("-undefined");
 788     GCCArgs.push_back("dynamic_lookup");
 789   } else
 790     GCCArgs.push_back("-shared");  // `-shared' for Linux/X86, maybe others
 791
 792   if ((TargetTriple.getArch() == Triple::alpha) ||
 793       (TargetTriple.getArch() == Triple::x86_64))
 794     GCCArgs.push_back("-fPIC");   // Requires shared objs to contain PIC
 795
 796   if (TargetTriple.getArch() == Triple::sparc)
 797     GCCArgs.push_back("-mcpu=v9");
 798
 799   GCCArgs.push_back("-o");
 800   GCCArgs.push_back(OutputFile.c_str()); // Output to the right filename.
 801   GCCArgs.push_back("-O2");              // Optimize the program a bit.
 802
 803
 804
 805   // Add any arguments intended for GCC. We locate them here because this is
 806   // most likely -L and -l options that need to come before other libraries but
 807   // after the source. Other options won't be sensitive to placement on the
 808   // command line, so this should be safe.
 809   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 810     GCCArgs.push_back(ArgsForGCC[i].c_str());
 811   GCCArgs.push_back(0);                    // NULL terminator
 812
 813
 814
 815   outs() << "<gcc>"; outs().flush();
 816   DEBUG(errs() << "\nAbout to run:\t";
 817         for (unsigned i=0, e = GCCArgs.size()-1; i != e; ++i)
 818           errs() << " " << GCCArgs[i];
 819         errs() << "\n";
 820         );
 821   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 822                             sys::Path())) {
 823     ProcessFailure(GCCPath, &GCCArgs[0]);
 824     return 1;
 825   }
 826   return 0;
 827 }
 828
 829 /// create - Try to find the `gcc' executable
 830 ///
 831 GCC *GCC::create(std::string &Message,
 832                  const std::vector<std::string> *Args) {
 833   sys::Path GCCPath = sys::Program::FindProgramByName("gcc");
 834   if (GCCPath.isEmpty()) {
 835     Message = "Cannot find `gcc' in executable directory or PATH!\n";
 836     return 0;
 837   }
 838
 839   sys::Path RemoteClientPath;
 840   if (!RemoteClient.empty())
 841     RemoteClientPath = sys::Program::FindProgramByName(RemoteClient);
 842
 843   Message = "Found gcc: " + GCCPath.str() + "\n";
 844   return new GCC(GCCPath, RemoteClientPath, Args);
 845 }