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   std::vector<const char*> LLIArgs;
 203   LLIArgs.push_back(LLIPath.c_str());
 204   LLIArgs.push_back("-force-interpreter=true");
 205
 206   for (std::vector<std::string>::const_iterator i = SharedLibs.begin(), e = SharedLibs.end(); i != e; ++i) {
 207     LLIArgs.push_back("-load");
 208     LLIArgs.push_back((*i).c_str());
 209   }
 210
 211   // Add any extra LLI args.
 212   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 213     LLIArgs.push_back(ToolArgs[i].c_str());
 214
 215   LLIArgs.push_back(Bitcode.c_str());
 216   // Add optional parameters to the running program from Argv
 217   for (unsigned i=0, e = Args.size(); i != e; ++i)
 218     LLIArgs.push_back(Args[i].c_str());
 219   LLIArgs.push_back(0);
 220
 221   outs() << "<lli>"; outs().flush();
 222   DEBUG(errs() << "\nAbout to run:\t";
 223         for (unsigned i=0, e = LLIArgs.size()-1; i != e; ++i)
 224           errs() << " " << LLIArgs[i];
 225         errs() << "\n";
 226         );
 227   return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
 228       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 229       Timeout, MemoryLimit);
 230 }
 231
 232 // LLI create method - Try to find the LLI executable
 233 AbstractInterpreter *AbstractInterpreter::createLLI(const char *Argv0,
 234                                                     std::string &Message,
 235                                      const std::vector<std::string> *ToolArgs) {
 236   std::string LLIPath =
 237     FindExecutable("lli", Argv0, (void *)(intptr_t)&createLLI).str();
 238   if (!LLIPath.empty()) {
 239     Message = "Found lli: " + LLIPath + "\n";
 240     return new LLI(LLIPath, ToolArgs);
 241   }
 242
 243   Message = "Cannot find `lli' in executable directory or PATH!\n";
 244   return 0;
 245 }
 246
 247 //===---------------------------------------------------------------------===//
 248 // Custom execution command implementation of AbstractIntepreter interface
 249 //
 250 // Allows using a custom command for executing the bitcode, thus allows,
 251 // for example, to invoke a cross compiler for code generation followed by
 252 // a simulator that executes the generated binary.
 253 namespace {
 254   class CustomExecutor : public AbstractInterpreter {
 255     std::string ExecutionCommand;
 256     std::vector<std::string> ExecutorArgs;
 257   public:
 258     CustomExecutor(
 259       const std::string &ExecutionCmd, std::vector<std::string> ExecArgs) :
 260       ExecutionCommand(ExecutionCmd), ExecutorArgs(ExecArgs) {}
 261
 262     virtual int ExecuteProgram(const std::string &Bitcode,
 263                                const std::vector<std::string> &Args,
 264                                const std::string &InputFile,
 265                                const std::string &OutputFile,
 266                                const std::vector<std::string> &GCCArgs,
 267                                const std::vector<std::string> &SharedLibs =
 268                                std::vector<std::string>(),
 269                                unsigned Timeout = 0,
 270                                unsigned MemoryLimit = 0);
 271   };
 272 }
 273
 274 int CustomExecutor::ExecuteProgram(const std::string &Bitcode,
 275                         const std::vector<std::string> &Args,
 276                         const std::string &InputFile,
 277                         const std::string &OutputFile,
 278                         const std::vector<std::string> &GCCArgs,
 279                         const std::vector<std::string> &SharedLibs,
 280                         unsigned Timeout,
 281                         unsigned MemoryLimit) {
 282
 283   std::vector<const char*> ProgramArgs;
 284   ProgramArgs.push_back(ExecutionCommand.c_str());
 285
 286   for (std::size_t i = 0; i < ExecutorArgs.size(); ++i)
 287     ProgramArgs.push_back(ExecutorArgs.at(i).c_str());
 288   ProgramArgs.push_back(Bitcode.c_str());
 289   ProgramArgs.push_back(0);
 290
 291   // Add optional parameters to the running program from Argv
 292   for (unsigned i=0, e = Args.size(); i != e; ++i)
 293     ProgramArgs.push_back(Args[i].c_str());
 294
 295   return RunProgramWithTimeout(
 296     sys::Path(ExecutionCommand),
 297     &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 298     sys::Path(OutputFile), Timeout, MemoryLimit);
 299 }
 300
 301 // Custom execution environment create method, takes the execution command
 302 // as arguments
 303 AbstractInterpreter *AbstractInterpreter::createCustom(
 304                     std::string &Message,
 305                     const std::string &ExecCommandLine) {
 306
 307   std::string Command = "";
 308   std::vector<std::string> Args;
 309   std::string delimiters = " ";
 310
 311   // Tokenize the ExecCommandLine to the command and the args to allow
 312   // defining a full command line as the command instead of just the
 313   // executed program. We cannot just pass the whole string after the command
 314   // as a single argument because then program sees only a single
 315   // command line argument (with spaces in it: "foo bar" instead
 316   // of "foo" and "bar").
 317
 318   // code borrowed from:
 319   // http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html
 320   std::string::size_type lastPos =
 321     ExecCommandLine.find_first_not_of(delimiters, 0);
 322   std::string::size_type pos =
 323     ExecCommandLine.find_first_of(delimiters, lastPos);
 324
 325   while (std::string::npos != pos || std::string::npos != lastPos) {
 326     std::string token = ExecCommandLine.substr(lastPos, pos - lastPos);
 327     if (Command == "")
 328        Command = token;
 329     else
 330        Args.push_back(token);
 331     // Skip delimiters.  Note the "not_of"
 332     lastPos = ExecCommandLine.find_first_not_of(delimiters, pos);
 333     // Find next "non-delimiter"
 334     pos = ExecCommandLine.find_first_of(delimiters, lastPos);
 335   }
 336
 337   std::string CmdPath = sys::Program::FindProgramByName(Command).str();
 338   if (CmdPath.empty()) {
 339     Message =
 340       std::string("Cannot find '") + Command +
 341       "' in executable directory or PATH!\n";
 342     return 0;
 343   }
 344
 345   Message = "Found command in: " + CmdPath + "\n";
 346
 347   return new CustomExecutor(CmdPath, Args);
 348 }
 349
 350 //===----------------------------------------------------------------------===//
 351 // LLC Implementation of AbstractIntepreter interface
 352 //
 353 GCC::FileType LLC::OutputCode(const std::string &Bitcode,
 354                               sys::Path &OutputAsmFile) {
 355   const char *Suffix = (UseIntegratedAssembler ? ".llc.o" : ".llc.s");
 356   sys::Path uniqueFile(Bitcode + Suffix);
 357   std::string ErrMsg;
 358   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 359     errs() << "Error making unique filename: " << ErrMsg << "\n";
 360     exit(1);
 361   }
 362   OutputAsmFile = uniqueFile;
 363   std::vector<const char *> LLCArgs;
 364   LLCArgs.push_back(LLCPath.c_str());
 365
 366   // Add any extra LLC args.
 367   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 368     LLCArgs.push_back(ToolArgs[i].c_str());
 369
 370   LLCArgs.push_back("-o");
 371   LLCArgs.push_back(OutputAsmFile.c_str()); // Output to the Asm file
 372   LLCArgs.push_back(Bitcode.c_str());      // This is the input bitcode
 373
 374   if (UseIntegratedAssembler)
 375     LLCArgs.push_back("-filetype=obj");
 376
 377   LLCArgs.push_back (0);
 378
 379   outs() << (UseIntegratedAssembler ? "<llc-ia>" : "<llc>");
 380   outs().flush();
 381   DEBUG(errs() << "\nAbout to run:\t";
 382         for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
 383           errs() << " " << LLCArgs[i];
 384         errs() << "\n";
 385         );
 386   if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
 387                             sys::Path(), sys::Path(), sys::Path()))
 388     ProcessFailure(sys::Path(LLCPath), &LLCArgs[0]);
 389
 390   return UseIntegratedAssembler ? GCC::ObjectFile : GCC::AsmFile;
 391 }
 392
 393 void LLC::compileProgram(const std::string &Bitcode) {
 394   sys::Path OutputAsmFile;
 395   OutputCode(Bitcode, OutputAsmFile);
 396   OutputAsmFile.eraseFromDisk();
 397 }
 398
 399 int LLC::ExecuteProgram(const std::string &Bitcode,
 400                         const std::vector<std::string> &Args,
 401                         const std::string &InputFile,
 402                         const std::string &OutputFile,
 403                         const std::vector<std::string> &ArgsForGCC,
 404                         const std::vector<std::string> &SharedLibs,
 405                         unsigned Timeout,
 406                         unsigned MemoryLimit) {
 407
 408   sys::Path OutputAsmFile;
 409   GCC::FileType FileKind = OutputCode(Bitcode, OutputAsmFile);
 410   FileRemover OutFileRemover(OutputAsmFile, !SaveTemps);
 411
 412   std::vector<std::string> GCCArgs(ArgsForGCC);
 413   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 414   GCCArgs.insert(GCCArgs.end(), gccArgs.begin(), gccArgs.end());
 415
 416   // Assuming LLC worked, compile the result with GCC and run it.
 417   return gcc->ExecuteProgram(OutputAsmFile.str(), Args, FileKind,
 418                              InputFile, OutputFile, GCCArgs,
 419                              Timeout, MemoryLimit);
 420 }
 421
 422 /// createLLC - Try to find the LLC executable
 423 ///
 424 LLC *AbstractInterpreter::createLLC(const char *Argv0,
 425                                     std::string &Message,
 426                                     const std::vector<std::string> *Args,
 427                                     const std::vector<std::string> *GCCArgs,
 428                                     bool UseIntegratedAssembler) {
 429   std::string LLCPath =
 430     FindExecutable("llc", Argv0, (void *)(intptr_t)&createLLC).str();
 431   if (LLCPath.empty()) {
 432     Message = "Cannot find `llc' in executable directory or PATH!\n";
 433     return 0;
 434   }
 435
 436   Message = "Found llc: " + LLCPath + "\n";
 437   GCC *gcc = GCC::create(Message, GCCArgs);
 438   if (!gcc) {
 439     errs() << Message << "\n";
 440     exit(1);
 441   }
 442   return new LLC(LLCPath, gcc, Args, GCCArgs, UseIntegratedAssembler);
 443 }
 444
 445 //===---------------------------------------------------------------------===//
 446 // JIT Implementation of AbstractIntepreter interface
 447 //
 448 namespace {
 449   class JIT : public AbstractInterpreter {
 450     std::string LLIPath;          // The path to the LLI executable
 451     std::vector<std::string> ToolArgs; // Args to pass to LLI
 452   public:
 453     JIT(const std::string &Path, const std::vector<std::string> *Args)
 454       : LLIPath(Path) {
 455       ToolArgs.clear ();
 456       if (Args) { ToolArgs = *Args; }
 457     }
 458
 459     virtual int ExecuteProgram(const std::string &Bitcode,
 460                                const std::vector<std::string> &Args,
 461                                const std::string &InputFile,
 462                                const std::string &OutputFile,
 463                                const std::vector<std::string> &GCCArgs =
 464                                  std::vector<std::string>(),
 465                                const std::vector<std::string> &SharedLibs =
 466                                  std::vector<std::string>(),
 467                                unsigned Timeout =0,
 468                                unsigned MemoryLimit =0);
 469   };
 470 }
 471
 472 int JIT::ExecuteProgram(const std::string &Bitcode,
 473                         const std::vector<std::string> &Args,
 474                         const std::string &InputFile,
 475                         const std::string &OutputFile,
 476                         const std::vector<std::string> &GCCArgs,
 477                         const std::vector<std::string> &SharedLibs,
 478                         unsigned Timeout,
 479                         unsigned MemoryLimit) {
 480   // Construct a vector of parameters, incorporating those from the command-line
 481   std::vector<const char*> JITArgs;
 482   JITArgs.push_back(LLIPath.c_str());
 483   JITArgs.push_back("-force-interpreter=false");
 484
 485   // Add any extra LLI args.
 486   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 487     JITArgs.push_back(ToolArgs[i].c_str());
 488
 489   for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
 490     JITArgs.push_back("-load");
 491     JITArgs.push_back(SharedLibs[i].c_str());
 492   }
 493   JITArgs.push_back(Bitcode.c_str());
 494   // Add optional parameters to the running program from Argv
 495   for (unsigned i=0, e = Args.size(); i != e; ++i)
 496     JITArgs.push_back(Args[i].c_str());
 497   JITArgs.push_back(0);
 498
 499   outs() << "<jit>"; outs().flush();
 500   DEBUG(errs() << "\nAbout to run:\t";
 501         for (unsigned i=0, e = JITArgs.size()-1; i != e; ++i)
 502           errs() << " " << JITArgs[i];
 503         errs() << "\n";
 504         );
 505   DEBUG(errs() << "\nSending output to " << OutputFile << "\n");
 506   return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
 507       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 508       Timeout, MemoryLimit);
 509 }
 510
 511 /// createJIT - Try to find the LLI executable
 512 ///
 513 AbstractInterpreter *AbstractInterpreter::createJIT(const char *Argv0,
 514                    std::string &Message, const std::vector<std::string> *Args) {
 515   std::string LLIPath =
 516     FindExecutable("lli", Argv0, (void *)(intptr_t)&createJIT).str();
 517   if (!LLIPath.empty()) {
 518     Message = "Found lli: " + LLIPath + "\n";
 519     return new JIT(LLIPath, Args);
 520   }
 521
 522   Message = "Cannot find `lli' in executable directory or PATH!\n";
 523   return 0;
 524 }
 525
 526 GCC::FileType CBE::OutputCode(const std::string &Bitcode,
 527                               sys::Path &OutputCFile) {
 528   sys::Path uniqueFile(Bitcode+".cbe.c");
 529   std::string ErrMsg;
 530   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 531     errs() << "Error making unique filename: " << ErrMsg << "\n";
 532     exit(1);
 533   }
 534   OutputCFile = uniqueFile;
 535   std::vector<const char *> LLCArgs;
 536   LLCArgs.push_back (LLCPath.c_str());
 537
 538   // Add any extra LLC args.
 539   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 540     LLCArgs.push_back(ToolArgs[i].c_str());
 541
 542   LLCArgs.push_back ("-o");
 543   LLCArgs.push_back (OutputCFile.c_str());   // Output to the C file
 544   LLCArgs.push_back ("-march=c");            // Output C language
 545   LLCArgs.push_back ("-f");                  // Overwrite as necessary...
 546   LLCArgs.push_back (Bitcode.c_str());      // This is the input bitcode
 547   LLCArgs.push_back (0);
 548
 549   outs() << "<cbe>"; outs().flush();
 550   DEBUG(errs() << "\nAbout to run:\t";
 551         for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
 552           errs() << " " << LLCArgs[i];
 553         errs() << "\n";
 554         );
 555   if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
 556                             sys::Path()))
 557     ProcessFailure(LLCPath, &LLCArgs[0]);
 558   return GCC::CFile;
 559 }
 560
 561 void CBE::compileProgram(const std::string &Bitcode) {
 562   sys::Path OutputCFile;
 563   OutputCode(Bitcode, OutputCFile);
 564   OutputCFile.eraseFromDisk();
 565 }
 566
 567 int CBE::ExecuteProgram(const std::string &Bitcode,
 568                         const std::vector<std::string> &Args,
 569                         const std::string &InputFile,
 570                         const std::string &OutputFile,
 571                         const std::vector<std::string> &ArgsForGCC,
 572                         const std::vector<std::string> &SharedLibs,
 573                         unsigned Timeout,
 574                         unsigned MemoryLimit) {
 575   sys::Path OutputCFile;
 576   OutputCode(Bitcode, OutputCFile);
 577
 578   FileRemover CFileRemove(OutputCFile, !SaveTemps);
 579
 580   std::vector<std::string> GCCArgs(ArgsForGCC);
 581   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 582
 583   return gcc->ExecuteProgram(OutputCFile.str(), Args, GCC::CFile,
 584                              InputFile, OutputFile, GCCArgs,
 585                              Timeout, MemoryLimit);
 586 }
 587
 588 /// createCBE - Try to find the 'llc' executable
 589 ///
 590 CBE *AbstractInterpreter::createCBE(const char *Argv0,
 591                                     std::string &Message,
 592                                     const std::vector<std::string> *Args,
 593                                     const std::vector<std::string> *GCCArgs) {
 594   sys::Path LLCPath =
 595     FindExecutable("llc", Argv0, (void *)(intptr_t)&createCBE);
 596   if (LLCPath.isEmpty()) {
 597     Message =
 598       "Cannot find `llc' in executable directory or PATH!\n";
 599     return 0;
 600   }
 601
 602   Message = "Found llc: " + LLCPath.str() + "\n";
 603   GCC *gcc = GCC::create(Message, GCCArgs);
 604   if (!gcc) {
 605     errs() << Message << "\n";
 606     exit(1);
 607   }
 608   return new CBE(LLCPath, gcc, Args);
 609 }
 610
 611 //===---------------------------------------------------------------------===//
 612 // GCC abstraction
 613 //
 614
 615 static bool IsARMArchitecture(std::vector<std::string> Args) {
 616   for (std::vector<std::string>::const_iterator
 617          I = Args.begin(), E = Args.end(); I != E; ++I) {
 618     StringRef S(*I);
 619     if (!S.equals_lower("-arch")) {
 620       ++I;
 621       if (I != E && !S.substr(0, strlen("arm")).equals_lower("arm"))
 622         return true;
 623     }
 624   }
 625
 626   return false;
 627 }
 628
 629 int GCC::ExecuteProgram(const std::string &ProgramFile,
 630                         const std::vector<std::string> &Args,
 631                         FileType fileType,
 632                         const std::string &InputFile,
 633                         const std::string &OutputFile,
 634                         const std::vector<std::string> &ArgsForGCC,
 635                         unsigned Timeout,
 636                         unsigned MemoryLimit) {
 637   std::vector<const char*> GCCArgs;
 638
 639   GCCArgs.push_back(GCCPath.c_str());
 640
 641   if (TargetTriple.getArch() == Triple::x86)
 642     GCCArgs.push_back("-m32");
 643
 644   for (std::vector<std::string>::const_iterator
 645          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 646     GCCArgs.push_back(I->c_str());
 647
 648   // Specify -x explicitly in case the extension is wonky
 649   if (fileType != ObjectFile) {
 650     GCCArgs.push_back("-x");
 651     if (fileType == CFile) {
 652       GCCArgs.push_back("c");
 653       GCCArgs.push_back("-fno-strict-aliasing");
 654     } else {
 655       GCCArgs.push_back("assembler");
 656
 657       // For ARM architectures we don't want this flag. bugpoint isn't
 658       // explicitly told what architecture it is working on, so we get
 659       // it from gcc flags
 660       if ((TargetTriple.getOS() == Triple::Darwin) &&
 661           !IsARMArchitecture(ArgsForGCC))
 662         GCCArgs.push_back("-force_cpusubtype_ALL");
 663     }
 664   }
 665
 666   GCCArgs.push_back(ProgramFile.c_str());  // Specify the input filename.
 667
 668   GCCArgs.push_back("-x");
 669   GCCArgs.push_back("none");
 670   GCCArgs.push_back("-o");
 671   sys::Path OutputBinary (ProgramFile+".gcc.exe");
 672   std::string ErrMsg;
 673   if (OutputBinary.makeUnique(true, &ErrMsg)) {
 674     errs() << "Error making unique filename: " << ErrMsg << "\n";
 675     exit(1);
 676   }
 677   GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
 678
 679   // Add any arguments intended for GCC. We locate them here because this is
 680   // most likely -L and -l options that need to come before other libraries but
 681   // after the source. Other options won't be sensitive to placement on the
 682   // command line, so this should be safe.
 683   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 684     GCCArgs.push_back(ArgsForGCC[i].c_str());
 685
 686   GCCArgs.push_back("-lm");                // Hard-code the math library...
 687   GCCArgs.push_back("-O2");                // Optimize the program a bit...
 688 #if defined (HAVE_LINK_R)
 689   GCCArgs.push_back("-Wl,-R.");            // Search this dir for .so files
 690 #endif
 691   if (TargetTriple.getArch() == Triple::sparc)
 692     GCCArgs.push_back("-mcpu=v9");
 693   GCCArgs.push_back(0);                    // NULL terminator
 694
 695   outs() << "<gcc>"; outs().flush();
 696   DEBUG(errs() << "\nAbout to run:\t";
 697         for (unsigned i=0, e = GCCArgs.size()-1; i != e; ++i)
 698           errs() << " " << GCCArgs[i];
 699         errs() << "\n";
 700         );
 701   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 702         sys::Path())) {
 703     ProcessFailure(GCCPath, &GCCArgs[0]);
 704     exit(1);
 705   }
 706
 707   std::vector<const char*> ProgramArgs;
 708
 709   if (RemoteClientPath.isEmpty())
 710     ProgramArgs.push_back(OutputBinary.c_str());
 711   else {
 712     ProgramArgs.push_back(RemoteClientPath.c_str());
 713     ProgramArgs.push_back(RemoteHost.c_str());
 714     if (!RemoteUser.empty()) {
 715       ProgramArgs.push_back("-l");
 716       ProgramArgs.push_back(RemoteUser.c_str());
 717     }
 718     if (!RemotePort.empty()) {
 719       ProgramArgs.push_back("-p");
 720       ProgramArgs.push_back(RemotePort.c_str());
 721     }
 722     if (!RemoteExtra.empty()) {
 723       ProgramArgs.push_back(RemoteExtra.c_str());
 724     }
 725
 726     // Full path to the binary. We need to cd to the exec directory because
 727     // there is a dylib there that the exec expects to find in the CWD
 728     char* env_pwd = getenv("PWD");
 729     std::string Exec = "cd ";
 730     Exec += env_pwd;
 731     Exec += "; ./";
 732     Exec += OutputBinary.c_str();
 733     ProgramArgs.push_back(Exec.c_str());
 734   }
 735
 736   // Add optional parameters to the running program from Argv
 737   for (unsigned i=0, e = Args.size(); i != e; ++i)
 738     ProgramArgs.push_back(Args[i].c_str());
 739   ProgramArgs.push_back(0);                // NULL terminator
 740
 741   // Now that we have a binary, run it!
 742   outs() << "<program>"; outs().flush();
 743   DEBUG(errs() << "\nAbout to run:\t";
 744         for (unsigned i=0, e = ProgramArgs.size()-1; i != e; ++i)
 745           errs() << " " << ProgramArgs[i];
 746         errs() << "\n";
 747         );
 748
 749   FileRemover OutputBinaryRemover(OutputBinary, !SaveTemps);
 750
 751   if (RemoteClientPath.isEmpty()) {
 752     DEBUG(errs() << "<run locally>";);
 753     return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
 754         sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 755         Timeout, MemoryLimit);
 756   } else {
 757     outs() << "<run remotely>"; outs().flush();
 758     return RunProgramRemotelyWithTimeout(sys::Path(RemoteClientPath),
 759         &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 760         sys::Path(OutputFile), Timeout, MemoryLimit);
 761   }
 762 }
 763
 764 int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType,
 765                           std::string &OutputFile,
 766                           const std::vector<std::string> &ArgsForGCC) {
 767   sys::Path uniqueFilename(InputFile+LTDL_SHLIB_EXT);
 768   std::string ErrMsg;
 769   if (uniqueFilename.makeUnique(true, &ErrMsg)) {
 770     errs() << "Error making unique filename: " << ErrMsg << "\n";
 771     exit(1);
 772   }
 773   OutputFile = uniqueFilename.str();
 774
 775   std::vector<const char*> GCCArgs;
 776
 777   GCCArgs.push_back(GCCPath.c_str());
 778
 779   if (TargetTriple.getArch() == Triple::x86)
 780     GCCArgs.push_back("-m32");
 781
 782   for (std::vector<std::string>::const_iterator
 783          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 784     GCCArgs.push_back(I->c_str());
 785
 786   // Compile the C/asm file into a shared object
 787   if (fileType != ObjectFile) {
 788     GCCArgs.push_back("-x");
 789     GCCArgs.push_back(fileType == AsmFile ? "assembler" : "c");
 790   }
 791   GCCArgs.push_back("-fno-strict-aliasing");
 792   GCCArgs.push_back(InputFile.c_str());   // Specify the input filename.
 793   GCCArgs.push_back("-x");
 794   GCCArgs.push_back("none");
 795   if (TargetTriple.getArch() == Triple::sparc)
 796     GCCArgs.push_back("-G");       // Compile a shared library, `-G' for Sparc
 797   else if (TargetTriple.getOS() == Triple::Darwin) {
 798     // link all source files into a single module in data segment, rather than
 799     // generating blocks. dynamic_lookup requires that you set
 800     // MACOSX_DEPLOYMENT_TARGET=10.3 in your env.  FIXME: it would be better for
 801     // bugpoint to just pass that in the environment of GCC.
 802     GCCArgs.push_back("-single_module");
 803     GCCArgs.push_back("-dynamiclib");   // `-dynamiclib' for MacOS X/PowerPC
 804     GCCArgs.push_back("-undefined");
 805     GCCArgs.push_back("dynamic_lookup");
 806   } else
 807     GCCArgs.push_back("-shared");  // `-shared' for Linux/X86, maybe others
 808
 809   if ((TargetTriple.getArch() == Triple::alpha) ||
 810       (TargetTriple.getArch() == Triple::x86_64))
 811     GCCArgs.push_back("-fPIC");   // Requires shared objs to contain PIC
 812
 813   if (TargetTriple.getArch() == Triple::sparc)
 814     GCCArgs.push_back("-mcpu=v9");
 815
 816   GCCArgs.push_back("-o");
 817   GCCArgs.push_back(OutputFile.c_str()); // Output to the right filename.
 818   GCCArgs.push_back("-O2");              // Optimize the program a bit.
 819
 820
 821
 822   // Add any arguments intended for GCC. We locate them here because this is
 823   // most likely -L and -l options that need to come before other libraries but
 824   // after the source. Other options won't be sensitive to placement on the
 825   // command line, so this should be safe.
 826   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 827     GCCArgs.push_back(ArgsForGCC[i].c_str());
 828   GCCArgs.push_back(0);                    // NULL terminator
 829
 830
 831
 832   outs() << "<gcc>"; outs().flush();
 833   DEBUG(errs() << "\nAbout to run:\t";
 834         for (unsigned i=0, e = GCCArgs.size()-1; i != e; ++i)
 835           errs() << " " << GCCArgs[i];
 836         errs() << "\n";
 837         );
 838   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 839                             sys::Path())) {
 840     ProcessFailure(GCCPath, &GCCArgs[0]);
 841     return 1;
 842   }
 843   return 0;
 844 }
 845
 846 /// create - Try to find the `gcc' executable
 847 ///
 848 GCC *GCC::create(std::string &Message,
 849                  const std::vector<std::string> *Args) {
 850   sys::Path GCCPath = sys::Program::FindProgramByName("gcc");
 851   if (GCCPath.isEmpty()) {
 852     Message = "Cannot find `gcc' in executable directory or PATH!\n";
 853     return 0;
 854   }
 855
 856   sys::Path RemoteClientPath;
 857   if (!RemoteClient.empty())
 858     RemoteClientPath = sys::Program::FindProgramByName(RemoteClient);
 859
 860   Message = "Found gcc: " + GCCPath.str() + "\n";
 861   return new GCC(GCCPath, RemoteClientPath, Args);
 862 }