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