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   sys::Path uniqueFile(Bitcode+".llc.s");
 356   std::string ErrMsg;
 357   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 358     errs() << "Error making unique filename: " << ErrMsg << "\n";
 359     exit(1);
 360   }
 361   OutputAsmFile = uniqueFile;
 362   std::vector<const char *> LLCArgs;
 363   LLCArgs.push_back (LLCPath.c_str());
 364
 365   // Add any extra LLC args.
 366   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 367     LLCArgs.push_back(ToolArgs[i].c_str());
 368
 369   LLCArgs.push_back ("-o");
 370   LLCArgs.push_back (OutputAsmFile.c_str()); // Output to the Asm file
 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.str(), 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, (void *)(intptr_t)&createLLC).str();
 424   if (LLCPath.empty()) {
 425     Message = "Cannot find `llc' in executable directory or PATH!\n";
 426     return 0;
 427   }
 428
 429   Message = "Found llc: " + LLCPath + "\n";
 430   GCC *gcc = GCC::create(Message, GCCArgs);
 431   if (!gcc) {
 432     errs() << Message << "\n";
 433     exit(1);
 434   }
 435   return new LLC(LLCPath, gcc, Args, GCCArgs);
 436 }
 437
 438 //===---------------------------------------------------------------------===//
 439 // JIT Implementation of AbstractIntepreter interface
 440 //
 441 namespace {
 442   class JIT : public AbstractInterpreter {
 443     std::string LLIPath;          // The path to the LLI executable
 444     std::vector<std::string> ToolArgs; // Args to pass to LLI
 445   public:
 446     JIT(const std::string &Path, const std::vector<std::string> *Args)
 447       : LLIPath(Path) {
 448       ToolArgs.clear ();
 449       if (Args) { ToolArgs = *Args; }
 450     }
 451
 452     virtual int ExecuteProgram(const std::string &Bitcode,
 453                                const std::vector<std::string> &Args,
 454                                const std::string &InputFile,
 455                                const std::string &OutputFile,
 456                                const std::vector<std::string> &GCCArgs =
 457                                  std::vector<std::string>(),
 458                                const std::vector<std::string> &SharedLibs =
 459                                  std::vector<std::string>(),
 460                                unsigned Timeout =0,
 461                                unsigned MemoryLimit =0);
 462   };
 463 }
 464
 465 int JIT::ExecuteProgram(const std::string &Bitcode,
 466                         const std::vector<std::string> &Args,
 467                         const std::string &InputFile,
 468                         const std::string &OutputFile,
 469                         const std::vector<std::string> &GCCArgs,
 470                         const std::vector<std::string> &SharedLibs,
 471                         unsigned Timeout,
 472                         unsigned MemoryLimit) {
 473   // Construct a vector of parameters, incorporating those from the command-line
 474   std::vector<const char*> JITArgs;
 475   JITArgs.push_back(LLIPath.c_str());
 476   JITArgs.push_back("-force-interpreter=false");
 477
 478   // Add any extra LLI args.
 479   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 480     JITArgs.push_back(ToolArgs[i].c_str());
 481
 482   for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
 483     JITArgs.push_back("-load");
 484     JITArgs.push_back(SharedLibs[i].c_str());
 485   }
 486   JITArgs.push_back(Bitcode.c_str());
 487   // Add optional parameters to the running program from Argv
 488   for (unsigned i=0, e = Args.size(); i != e; ++i)
 489     JITArgs.push_back(Args[i].c_str());
 490   JITArgs.push_back(0);
 491
 492   outs() << "<jit>"; outs().flush();
 493   DEBUG(errs() << "\nAbout to run:\t";
 494         for (unsigned i=0, e = JITArgs.size()-1; i != e; ++i)
 495           errs() << " " << JITArgs[i];
 496         errs() << "\n";
 497         );
 498   DEBUG(errs() << "\nSending output to " << OutputFile << "\n");
 499   return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
 500       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 501       Timeout, MemoryLimit);
 502 }
 503
 504 /// createJIT - Try to find the LLI executable
 505 ///
 506 AbstractInterpreter *AbstractInterpreter::createJIT(const char *Argv0,
 507                    std::string &Message, const std::vector<std::string> *Args) {
 508   std::string LLIPath =
 509     FindExecutable("lli", Argv0, (void *)(intptr_t)&createJIT).str();
 510   if (!LLIPath.empty()) {
 511     Message = "Found lli: " + LLIPath + "\n";
 512     return new JIT(LLIPath, Args);
 513   }
 514
 515   Message = "Cannot find `lli' in executable directory or PATH!\n";
 516   return 0;
 517 }
 518
 519 GCC::FileType CBE::OutputCode(const std::string &Bitcode,
 520                               sys::Path &OutputCFile) {
 521   sys::Path uniqueFile(Bitcode+".cbe.c");
 522   std::string ErrMsg;
 523   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 524     errs() << "Error making unique filename: " << ErrMsg << "\n";
 525     exit(1);
 526   }
 527   OutputCFile = uniqueFile;
 528   std::vector<const char *> LLCArgs;
 529   LLCArgs.push_back (LLCPath.c_str());
 530
 531   // Add any extra LLC args.
 532   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 533     LLCArgs.push_back(ToolArgs[i].c_str());
 534
 535   LLCArgs.push_back ("-o");
 536   LLCArgs.push_back (OutputCFile.c_str());   // Output to the C file
 537   LLCArgs.push_back ("-march=c");            // Output C language
 538   LLCArgs.push_back ("-f");                  // Overwrite as necessary...
 539   LLCArgs.push_back (Bitcode.c_str());      // This is the input bitcode
 540   LLCArgs.push_back (0);
 541
 542   outs() << "<cbe>"; outs().flush();
 543   DEBUG(errs() << "\nAbout to run:\t";
 544         for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
 545           errs() << " " << LLCArgs[i];
 546         errs() << "\n";
 547         );
 548   if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
 549                             sys::Path()))
 550     ProcessFailure(LLCPath, &LLCArgs[0]);
 551   return GCC::CFile;
 552 }
 553
 554 void CBE::compileProgram(const std::string &Bitcode) {
 555   sys::Path OutputCFile;
 556   OutputCode(Bitcode, OutputCFile);
 557   OutputCFile.eraseFromDisk();
 558 }
 559
 560 int CBE::ExecuteProgram(const std::string &Bitcode,
 561                         const std::vector<std::string> &Args,
 562                         const std::string &InputFile,
 563                         const std::string &OutputFile,
 564                         const std::vector<std::string> &ArgsForGCC,
 565                         const std::vector<std::string> &SharedLibs,
 566                         unsigned Timeout,
 567                         unsigned MemoryLimit) {
 568   sys::Path OutputCFile;
 569   OutputCode(Bitcode, OutputCFile);
 570
 571   FileRemover CFileRemove(OutputCFile, !SaveTemps);
 572
 573   std::vector<std::string> GCCArgs(ArgsForGCC);
 574   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 575
 576   return gcc->ExecuteProgram(OutputCFile.str(), Args, GCC::CFile,
 577                              InputFile, OutputFile, GCCArgs,
 578                              Timeout, MemoryLimit);
 579 }
 580
 581 /// createCBE - Try to find the 'llc' executable
 582 ///
 583 CBE *AbstractInterpreter::createCBE(const char *Argv0,
 584                                     std::string &Message,
 585                                     const std::vector<std::string> *Args,
 586                                     const std::vector<std::string> *GCCArgs) {
 587   sys::Path LLCPath =
 588     FindExecutable("llc", Argv0, (void *)(intptr_t)&createCBE);
 589   if (LLCPath.isEmpty()) {
 590     Message =
 591       "Cannot find `llc' in executable directory or PATH!\n";
 592     return 0;
 593   }
 594
 595   Message = "Found llc: " + LLCPath.str() + "\n";
 596   GCC *gcc = GCC::create(Message, GCCArgs);
 597   if (!gcc) {
 598     errs() << Message << "\n";
 599     exit(1);
 600   }
 601   return new CBE(LLCPath, gcc, Args);
 602 }
 603
 604 //===---------------------------------------------------------------------===//
 605 // GCC abstraction
 606 //
 607
 608 static bool
 609 IsARMArchitecture(std::vector<std::string> Args)
 610 {
 611   for (std::vector<std::string>::const_iterator
 612          I = Args.begin(), E = Args.end(); I != E; ++I) {
 613     StringRef S(*I);
 614     if (!S.equals_lower("-arch")) {
 615       ++I;
 616       if (I != E && !S.substr(0, strlen("arm")).equals_lower("arm")) {
 617         return true;
 618       }
 619     }
 620   }
 621
 622   return false;
 623 }
 624
 625 int GCC::ExecuteProgram(const std::string &ProgramFile,
 626                         const std::vector<std::string> &Args,
 627                         FileType fileType,
 628                         const std::string &InputFile,
 629                         const std::string &OutputFile,
 630                         const std::vector<std::string> &ArgsForGCC,
 631                         unsigned Timeout,
 632                         unsigned MemoryLimit) {
 633   std::vector<const char*> GCCArgs;
 634
 635   GCCArgs.push_back(GCCPath.c_str());
 636
 637   for (std::vector<std::string>::const_iterator
 638          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 639     GCCArgs.push_back(I->c_str());
 640
 641   // Specify -x explicitly in case the extension is wonky
 642   GCCArgs.push_back("-x");
 643   if (fileType == CFile) {
 644     GCCArgs.push_back("c");
 645     GCCArgs.push_back("-fno-strict-aliasing");
 646   } else {
 647     GCCArgs.push_back("assembler");
 648
 649     // For ARM architectures we don't want this flag. bugpoint isn't
 650     // explicitly told what architecture it is working on, so we get
 651     // it from gcc flags
 652     if ((TargetTriple.getOS() == Triple::Darwin) &&
 653         !IsARMArchitecture(ArgsForGCC))
 654       GCCArgs.push_back("-force_cpusubtype_ALL");
 655   }
 656   GCCArgs.push_back(ProgramFile.c_str());  // Specify the input filename...
 657   GCCArgs.push_back("-x");
 658   GCCArgs.push_back("none");
 659   GCCArgs.push_back("-o");
 660   sys::Path OutputBinary (ProgramFile+".gcc.exe");
 661   std::string ErrMsg;
 662   if (OutputBinary.makeUnique(true, &ErrMsg)) {
 663     errs() << "Error making unique filename: " << ErrMsg << "\n";
 664     exit(1);
 665   }
 666   GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
 667
 668   // Add any arguments intended for GCC. We locate them here because this is
 669   // most likely -L and -l options that need to come before other libraries but
 670   // after the source. Other options won't be sensitive to placement on the
 671   // command line, so this should be safe.
 672   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 673     GCCArgs.push_back(ArgsForGCC[i].c_str());
 674
 675   GCCArgs.push_back("-lm");                // Hard-code the math library...
 676   GCCArgs.push_back("-O2");                // Optimize the program a bit...
 677 #if defined (HAVE_LINK_R)
 678   GCCArgs.push_back("-Wl,-R.");            // Search this dir for .so files
 679 #endif
 680   if (TargetTriple.getArch() == Triple::sparc)
 681     GCCArgs.push_back("-mcpu=v9");
 682   GCCArgs.push_back(0);                    // NULL terminator
 683
 684   outs() << "<gcc>"; outs().flush();
 685   DEBUG(errs() << "\nAbout to run:\t";
 686         for (unsigned i=0, e = GCCArgs.size()-1; i != e; ++i)
 687           errs() << " " << GCCArgs[i];
 688         errs() << "\n";
 689         );
 690   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 691         sys::Path())) {
 692     ProcessFailure(GCCPath, &GCCArgs[0]);
 693     exit(1);
 694   }
 695
 696   std::vector<const char*> ProgramArgs;
 697
 698   if (RemoteClientPath.isEmpty())
 699     ProgramArgs.push_back(OutputBinary.c_str());
 700   else {
 701     ProgramArgs.push_back(RemoteClientPath.c_str());
 702     ProgramArgs.push_back(RemoteHost.c_str());
 703     if (!RemoteUser.empty()) {
 704       ProgramArgs.push_back("-l");
 705       ProgramArgs.push_back(RemoteUser.c_str());
 706     }
 707     if (!RemotePort.empty()) {
 708       ProgramArgs.push_back("-p");
 709       ProgramArgs.push_back(RemotePort.c_str());
 710     }
 711     if (!RemoteExtra.empty()) {
 712       ProgramArgs.push_back(RemoteExtra.c_str());
 713     }
 714
 715     // Full path to the binary. We need to cd to the exec directory because
 716     // there is a dylib there that the exec expects to find in the CWD
 717     char* env_pwd = getenv("PWD");
 718     std::string Exec = "cd ";
 719     Exec += env_pwd;
 720     Exec += "; ./";
 721     Exec += OutputBinary.c_str();
 722     ProgramArgs.push_back(Exec.c_str());
 723   }
 724
 725   // Add optional parameters to the running program from Argv
 726   for (unsigned i=0, e = Args.size(); i != e; ++i)
 727     ProgramArgs.push_back(Args[i].c_str());
 728   ProgramArgs.push_back(0);                // NULL terminator
 729
 730   // Now that we have a binary, run it!
 731   outs() << "<program>"; outs().flush();
 732   DEBUG(errs() << "\nAbout to run:\t";
 733         for (unsigned i=0, e = ProgramArgs.size()-1; i != e; ++i)
 734           errs() << " " << ProgramArgs[i];
 735         errs() << "\n";
 736         );
 737
 738   FileRemover OutputBinaryRemover(OutputBinary, !SaveTemps);
 739
 740   if (RemoteClientPath.isEmpty()) {
 741     DEBUG(errs() << "<run locally>";);
 742     return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
 743         sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 744         Timeout, MemoryLimit);
 745   } else {
 746     outs() << "<run remotely>"; outs().flush();
 747     return RunProgramRemotelyWithTimeout(sys::Path(RemoteClientPath),
 748         &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 749         sys::Path(OutputFile), Timeout, MemoryLimit);
 750   }
 751 }
 752
 753 int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType,
 754                           std::string &OutputFile,
 755                           const std::vector<std::string> &ArgsForGCC) {
 756   sys::Path uniqueFilename(InputFile+LTDL_SHLIB_EXT);
 757   std::string ErrMsg;
 758   if (uniqueFilename.makeUnique(true, &ErrMsg)) {
 759     errs() << "Error making unique filename: " << ErrMsg << "\n";
 760     exit(1);
 761   }
 762   OutputFile = uniqueFilename.str();
 763
 764   std::vector<const char*> GCCArgs;
 765
 766   GCCArgs.push_back(GCCPath.c_str());
 767
 768   for (std::vector<std::string>::const_iterator
 769          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 770     GCCArgs.push_back(I->c_str());
 771
 772   // Compile the C/asm file into a shared object
 773   GCCArgs.push_back("-x");
 774   GCCArgs.push_back(fileType == AsmFile ? "assembler" : "c");
 775   GCCArgs.push_back("-fno-strict-aliasing");
 776   GCCArgs.push_back(InputFile.c_str());   // Specify the input filename.
 777   GCCArgs.push_back("-x");
 778   GCCArgs.push_back("none");
 779   if (TargetTriple.getArch() == Triple::sparc)
 780     GCCArgs.push_back("-G");       // Compile a shared library, `-G' for Sparc
 781   else if (TargetTriple.getOS() == Triple::Darwin) {
 782     // link all source files into a single module in data segment, rather than
 783     // generating blocks. dynamic_lookup requires that you set
 784     // MACOSX_DEPLOYMENT_TARGET=10.3 in your env.  FIXME: it would be better for
 785     // bugpoint to just pass that in the environment of GCC.
 786     GCCArgs.push_back("-single_module");
 787     GCCArgs.push_back("-dynamiclib");   // `-dynamiclib' for MacOS X/PowerPC
 788     GCCArgs.push_back("-undefined");
 789     GCCArgs.push_back("dynamic_lookup");
 790   } else
 791     GCCArgs.push_back("-shared");  // `-shared' for Linux/X86, maybe others
 792
 793   if ((TargetTriple.getArch() == Triple::alpha) ||
 794       (TargetTriple.getArch() == Triple::x86_64))
 795     GCCArgs.push_back("-fPIC");   // Requires shared objs to contain PIC
 796
 797   if (TargetTriple.getArch() == Triple::sparc)
 798     GCCArgs.push_back("-mcpu=v9");
 799
 800   GCCArgs.push_back("-o");
 801   GCCArgs.push_back(OutputFile.c_str()); // Output to the right filename.
 802   GCCArgs.push_back("-O2");              // Optimize the program a bit.
 803
 804
 805
 806   // Add any arguments intended for GCC. We locate them here because this is
 807   // most likely -L and -l options that need to come before other libraries but
 808   // after the source. Other options won't be sensitive to placement on the
 809   // command line, so this should be safe.
 810   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 811     GCCArgs.push_back(ArgsForGCC[i].c_str());
 812   GCCArgs.push_back(0);                    // NULL terminator
 813
 814
 815
 816   outs() << "<gcc>"; outs().flush();
 817   DEBUG(errs() << "\nAbout to run:\t";
 818         for (unsigned i=0, e = GCCArgs.size()-1; i != e; ++i)
 819           errs() << " " << GCCArgs[i];
 820         errs() << "\n";
 821         );
 822   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 823                             sys::Path())) {
 824     ProcessFailure(GCCPath, &GCCArgs[0]);
 825     return 1;
 826   }
 827   return 0;
 828 }
 829
 830 /// create - Try to find the `gcc' executable
 831 ///
 832 GCC *GCC::create(std::string &Message,
 833                  const std::vector<std::string> *Args) {
 834   sys::Path GCCPath = sys::Program::FindProgramByName("gcc");
 835   if (GCCPath.isEmpty()) {
 836     Message = "Cannot find `gcc' in executable directory or PATH!\n";
 837     return 0;
 838   }
 839
 840   sys::Path RemoteClientPath;
 841   if (!RemoteClient.empty())
 842     RemoteClientPath = sys::Program::FindProgramByName(RemoteClient);
 843
 844   Message = "Found gcc: " + GCCPath.str() + "\n";
 845   return new GCC(GCCPath, RemoteClientPath, Args);
 846 }