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/Support/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 /// RunProgramWithTimeout - This function provides an alternate interface
  54 /// to the sys::Program::ExecuteAndWait interface.
  55 /// @see sys::Program::ExecuteAndWait
  56 static int RunProgramWithTimeout(const sys::Path &ProgramPath,
  57                                  const char **Args,
  58                                  const sys::Path &StdInFile,
  59                                  const sys::Path &StdOutFile,
  60                                  const sys::Path &StdErrFile,
  61                                  unsigned NumSeconds = 0,
  62                                  unsigned MemoryLimit = 0,
  63                                  std::string *ErrMsg = 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, ErrMsg);
  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     errs() << OS;
 132   }
 133
 134   return ReturnCode;
 135 }
 136
 137 static std::string ProcessFailure(sys::Path ProgPath, const char** Args,
 138                                   unsigned Timeout = 0,
 139                                   unsigned MemoryLimit = 0) {
 140   std::ostringstream OS;
 141   OS << "\nError running tool:\n ";
 142   for (const char **Arg = Args; *Arg; ++Arg)
 143     OS << " " << *Arg;
 144   OS << "\n";
 145
 146   // Rerun the compiler, capturing any error messages to print them.
 147   sys::Path ErrorFilename("bugpoint.program_error_messages");
 148   std::string ErrMsg;
 149   if (ErrorFilename.makeUnique(true, &ErrMsg)) {
 150     errs() << "Error making unique filename: " << ErrMsg << "\n";
 151     exit(1);
 152   }
 153   RunProgramWithTimeout(ProgPath, Args, sys::Path(""), ErrorFilename,
 154                         ErrorFilename, Timeout, MemoryLimit);
 155   // FIXME: check return code ?
 156
 157   // Print out the error messages generated by GCC if possible...
 158   std::ifstream ErrorFile(ErrorFilename.c_str());
 159   if (ErrorFile) {
 160     std::copy(std::istreambuf_iterator<char>(ErrorFile),
 161               std::istreambuf_iterator<char>(),
 162               std::ostreambuf_iterator<char>(OS));
 163     ErrorFile.close();
 164   }
 165
 166   ErrorFilename.eraseFromDisk();
 167   return OS.str();
 168 }
 169
 170 //===---------------------------------------------------------------------===//
 171 // LLI Implementation of AbstractIntepreter interface
 172 //
 173 namespace {
 174   class LLI : public AbstractInterpreter {
 175     std::string LLIPath;          // The path to the LLI executable
 176     std::vector<std::string> ToolArgs; // Args to pass to LLI
 177   public:
 178     LLI(const std::string &Path, const std::vector<std::string> *Args)
 179       : LLIPath(Path) {
 180       ToolArgs.clear ();
 181       if (Args) { ToolArgs = *Args; }
 182     }
 183
 184     virtual int ExecuteProgram(const std::string &Bitcode,
 185                                const std::vector<std::string> &Args,
 186                                const std::string &InputFile,
 187                                const std::string &OutputFile,
 188                                std::string *Error,
 189                                const std::vector<std::string> &GCCArgs,
 190                                const std::vector<std::string> &SharedLibs =
 191                                std::vector<std::string>(),
 192                                unsigned Timeout = 0,
 193                                unsigned MemoryLimit = 0);
 194   };
 195 }
 196
 197 int LLI::ExecuteProgram(const std::string &Bitcode,
 198                         const std::vector<std::string> &Args,
 199                         const std::string &InputFile,
 200                         const std::string &OutputFile,
 201                         std::string *Error,
 202                         const std::vector<std::string> &GCCArgs,
 203                         const std::vector<std::string> &SharedLibs,
 204                         unsigned Timeout,
 205                         unsigned MemoryLimit) {
 206   std::vector<const char*> LLIArgs;
 207   LLIArgs.push_back(LLIPath.c_str());
 208   LLIArgs.push_back("-force-interpreter=true");
 209
 210   for (std::vector<std::string>::const_iterator i = SharedLibs.begin(),
 211          e = SharedLibs.end(); i != e; ++i) {
 212     LLIArgs.push_back("-load");
 213     LLIArgs.push_back((*i).c_str());
 214   }
 215
 216   // Add any extra LLI args.
 217   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 218     LLIArgs.push_back(ToolArgs[i].c_str());
 219
 220   LLIArgs.push_back(Bitcode.c_str());
 221   // Add optional parameters to the running program from Argv
 222   for (unsigned i=0, e = Args.size(); i != e; ++i)
 223     LLIArgs.push_back(Args[i].c_str());
 224   LLIArgs.push_back(0);
 225
 226   outs() << "<lli>"; outs().flush();
 227   DEBUG(errs() << "\nAbout to run:\t";
 228         for (unsigned i=0, e = LLIArgs.size()-1; i != e; ++i)
 229           errs() << " " << LLIArgs[i];
 230         errs() << "\n";
 231         );
 232   return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
 233       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 234       Timeout, MemoryLimit, Error);
 235 }
 236
 237 // LLI create method - Try to find the LLI executable
 238 AbstractInterpreter *AbstractInterpreter::createLLI(const char *Argv0,
 239                                                     std::string &Message,
 240                                      const std::vector<std::string> *ToolArgs) {
 241   std::string LLIPath =
 242     PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t)&createLLI).str();
 243   if (!LLIPath.empty()) {
 244     Message = "Found lli: " + LLIPath + "\n";
 245     return new LLI(LLIPath, ToolArgs);
 246   }
 247
 248   Message = "Cannot find `lli' in executable directory!\n";
 249   return 0;
 250 }
 251
 252 //===---------------------------------------------------------------------===//
 253 // Custom compiler command implementation of AbstractIntepreter interface
 254 //
 255 // Allows using a custom command for compiling the bitcode, thus allows, for
 256 // example, to compile a bitcode fragment without linking or executing, then
 257 // using a custom wrapper script to check for compiler errors.
 258 namespace {
 259   class CustomCompiler : public AbstractInterpreter {
 260     std::string CompilerCommand;
 261     std::vector<std::string> CompilerArgs;
 262   public:
 263     CustomCompiler(
 264       const std::string &CompilerCmd, std::vector<std::string> CompArgs) :
 265       CompilerCommand(CompilerCmd), CompilerArgs(CompArgs) {}
 266
 267     virtual void compileProgram(const std::string &Bitcode,
 268                                 std::string *Error,
 269                                 unsigned Timeout = 0,
 270                                 unsigned MemoryLimit = 0);
 271
 272     virtual int ExecuteProgram(const std::string &Bitcode,
 273                                const std::vector<std::string> &Args,
 274                                const std::string &InputFile,
 275                                const std::string &OutputFile,
 276                                std::string *Error,
 277                                const std::vector<std::string> &GCCArgs =
 278                                std::vector<std::string>(),
 279                                const std::vector<std::string> &SharedLibs =
 280                                std::vector<std::string>(),
 281                                unsigned Timeout = 0,
 282                                unsigned MemoryLimit = 0) {
 283       *Error = "Execution not supported with -compile-custom";
 284       return -1;
 285     }
 286   };
 287 }
 288
 289 void CustomCompiler::compileProgram(const std::string &Bitcode,
 290                                     std::string *Error,
 291                                     unsigned Timeout,
 292                                     unsigned MemoryLimit) {
 293
 294   std::vector<const char*> ProgramArgs;
 295   ProgramArgs.push_back(CompilerCommand.c_str());
 296
 297   for (std::size_t i = 0; i < CompilerArgs.size(); ++i)
 298     ProgramArgs.push_back(CompilerArgs.at(i).c_str());
 299   ProgramArgs.push_back(Bitcode.c_str());
 300   ProgramArgs.push_back(0);
 301
 302   // Add optional parameters to the running program from Argv
 303   for (unsigned i = 0, e = CompilerArgs.size(); i != e; ++i)
 304     ProgramArgs.push_back(CompilerArgs[i].c_str());
 305
 306   if (RunProgramWithTimeout( sys::Path(CompilerCommand), &ProgramArgs[0],
 307                              sys::Path(), sys::Path(), sys::Path(),
 308                              Timeout, MemoryLimit, Error))
 309     *Error = ProcessFailure(sys::Path(CompilerCommand), &ProgramArgs[0],
 310                            Timeout, MemoryLimit);
 311 }
 312
 313 //===---------------------------------------------------------------------===//
 314 // Custom execution command implementation of AbstractIntepreter interface
 315 //
 316 // Allows using a custom command for executing the bitcode, thus allows,
 317 // for example, to invoke a cross compiler for code generation followed by
 318 // a simulator that executes the generated binary.
 319 namespace {
 320   class CustomExecutor : public AbstractInterpreter {
 321     std::string ExecutionCommand;
 322     std::vector<std::string> ExecutorArgs;
 323   public:
 324     CustomExecutor(
 325       const std::string &ExecutionCmd, std::vector<std::string> ExecArgs) :
 326       ExecutionCommand(ExecutionCmd), ExecutorArgs(ExecArgs) {}
 327
 328     virtual int ExecuteProgram(const std::string &Bitcode,
 329                                const std::vector<std::string> &Args,
 330                                const std::string &InputFile,
 331                                const std::string &OutputFile,
 332                                std::string *Error,
 333                                const std::vector<std::string> &GCCArgs,
 334                                const std::vector<std::string> &SharedLibs =
 335                                  std::vector<std::string>(),
 336                                unsigned Timeout = 0,
 337                                unsigned MemoryLimit = 0);
 338   };
 339 }
 340
 341 int CustomExecutor::ExecuteProgram(const std::string &Bitcode,
 342                         const std::vector<std::string> &Args,
 343                         const std::string &InputFile,
 344                         const std::string &OutputFile,
 345                         std::string *Error,
 346                         const std::vector<std::string> &GCCArgs,
 347                         const std::vector<std::string> &SharedLibs,
 348                         unsigned Timeout,
 349                         unsigned MemoryLimit) {
 350
 351   std::vector<const char*> ProgramArgs;
 352   ProgramArgs.push_back(ExecutionCommand.c_str());
 353
 354   for (std::size_t i = 0; i < ExecutorArgs.size(); ++i)
 355     ProgramArgs.push_back(ExecutorArgs.at(i).c_str());
 356   ProgramArgs.push_back(Bitcode.c_str());
 357   ProgramArgs.push_back(0);
 358
 359   // Add optional parameters to the running program from Argv
 360   for (unsigned i = 0, e = Args.size(); i != e; ++i)
 361     ProgramArgs.push_back(Args[i].c_str());
 362
 363   return RunProgramWithTimeout(
 364     sys::Path(ExecutionCommand),
 365     &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 366     sys::Path(OutputFile), Timeout, MemoryLimit, Error);
 367 }
 368
 369 // Tokenize the CommandLine to the command and the args to allow
 370 // defining a full command line as the command instead of just the
 371 // executed program. We cannot just pass the whole string after the command
 372 // as a single argument because then program sees only a single
 373 // command line argument (with spaces in it: "foo bar" instead
 374 // of "foo" and "bar").
 375 //
 376 // code borrowed from:
 377 // http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html
 378 static void lexCommand(std::string &Message, const std::string &CommandLine,
 379                        std::string &CmdPath, std::vector<std::string> Args) {
 380
 381   std::string Command = "";
 382   std::string delimiters = " ";
 383
 384   std::string::size_type lastPos = CommandLine.find_first_not_of(delimiters, 0);
 385   std::string::size_type pos = CommandLine.find_first_of(delimiters, lastPos);
 386
 387   while (std::string::npos != pos || std::string::npos != lastPos) {
 388     std::string token = CommandLine.substr(lastPos, pos - lastPos);
 389     if (Command == "")
 390        Command = token;
 391     else
 392        Args.push_back(token);
 393     // Skip delimiters.  Note the "not_of"
 394     lastPos = CommandLine.find_first_not_of(delimiters, pos);
 395     // Find next "non-delimiter"
 396     pos = CommandLine.find_first_of(delimiters, lastPos);
 397   }
 398
 399   CmdPath = sys::Program::FindProgramByName(Command).str();
 400   if (CmdPath.empty()) {
 401     Message =
 402       std::string("Cannot find '") + Command +
 403       "' in PATH!\n";
 404     return;
 405   }
 406
 407   Message = "Found command in: " + CmdPath + "\n";
 408 }
 409
 410 // Custom execution environment create method, takes the execution command
 411 // as arguments
 412 AbstractInterpreter *AbstractInterpreter::createCustomCompiler(
 413                     std::string &Message,
 414                     const std::string &CompileCommandLine) {
 415
 416   std::string CmdPath;
 417   std::vector<std::string> Args;
 418   lexCommand(Message, CompileCommandLine, CmdPath, Args);
 419   if (CmdPath.empty())
 420     return 0;
 421
 422   return new CustomCompiler(CmdPath, Args);
 423 }
 424
 425 // Custom execution environment create method, takes the execution command
 426 // as arguments
 427 AbstractInterpreter *AbstractInterpreter::createCustomExecutor(
 428                     std::string &Message,
 429                     const std::string &ExecCommandLine) {
 430
 431
 432   std::string CmdPath;
 433   std::vector<std::string> Args;
 434   lexCommand(Message, ExecCommandLine, CmdPath, Args);
 435   if (CmdPath.empty())
 436     return 0;
 437
 438   return new CustomExecutor(CmdPath, Args);
 439 }
 440
 441 //===----------------------------------------------------------------------===//
 442 // LLC Implementation of AbstractIntepreter interface
 443 //
 444 GCC::FileType LLC::OutputCode(const std::string &Bitcode,
 445                               sys::Path &OutputAsmFile, std::string &Error,
 446                               unsigned Timeout, unsigned MemoryLimit) {
 447   const char *Suffix = (UseIntegratedAssembler ? ".llc.o" : ".llc.s");
 448   sys::Path uniqueFile(Bitcode + Suffix);
 449   std::string ErrMsg;
 450   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 451     errs() << "Error making unique filename: " << ErrMsg << "\n";
 452     exit(1);
 453   }
 454   OutputAsmFile = uniqueFile;
 455   std::vector<const char *> LLCArgs;
 456   LLCArgs.push_back(LLCPath.c_str());
 457
 458   // Add any extra LLC args.
 459   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 460     LLCArgs.push_back(ToolArgs[i].c_str());
 461
 462   LLCArgs.push_back("-o");
 463   LLCArgs.push_back(OutputAsmFile.c_str()); // Output to the Asm file
 464   LLCArgs.push_back(Bitcode.c_str());      // This is the input bitcode
 465
 466   if (UseIntegratedAssembler)
 467     LLCArgs.push_back("-filetype=obj");
 468
 469   LLCArgs.push_back (0);
 470
 471   outs() << (UseIntegratedAssembler ? "<llc-ia>" : "<llc>");
 472   outs().flush();
 473   DEBUG(errs() << "\nAbout to run:\t";
 474         for (unsigned i = 0, e = LLCArgs.size()-1; i != e; ++i)
 475           errs() << " " << LLCArgs[i];
 476         errs() << "\n";
 477         );
 478   if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
 479                             sys::Path(), sys::Path(), sys::Path(),
 480                             Timeout, MemoryLimit))
 481     Error = ProcessFailure(sys::Path(LLCPath), &LLCArgs[0],
 482                            Timeout, MemoryLimit);
 483   return UseIntegratedAssembler ? GCC::ObjectFile : GCC::AsmFile;
 484 }
 485
 486 void LLC::compileProgram(const std::string &Bitcode, std::string *Error,
 487                          unsigned Timeout, unsigned MemoryLimit) {
 488   sys::Path OutputAsmFile;
 489   OutputCode(Bitcode, OutputAsmFile, *Error, Timeout, MemoryLimit);
 490   OutputAsmFile.eraseFromDisk();
 491 }
 492
 493 int LLC::ExecuteProgram(const std::string &Bitcode,
 494                         const std::vector<std::string> &Args,
 495                         const std::string &InputFile,
 496                         const std::string &OutputFile,
 497                         std::string *Error,
 498                         const std::vector<std::string> &ArgsForGCC,
 499                         const std::vector<std::string> &SharedLibs,
 500                         unsigned Timeout,
 501                         unsigned MemoryLimit) {
 502
 503   sys::Path OutputAsmFile;
 504   GCC::FileType FileKind = OutputCode(Bitcode, OutputAsmFile, *Error, Timeout,
 505                                       MemoryLimit);
 506   FileRemover OutFileRemover(OutputAsmFile.str(), !SaveTemps);
 507
 508   std::vector<std::string> GCCArgs(ArgsForGCC);
 509   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 510
 511   // Assuming LLC worked, compile the result with GCC and run it.
 512   return gcc->ExecuteProgram(OutputAsmFile.str(), Args, FileKind,
 513                              InputFile, OutputFile, Error, GCCArgs,
 514                              Timeout, MemoryLimit);
 515 }
 516
 517 /// createLLC - Try to find the LLC executable
 518 ///
 519 LLC *AbstractInterpreter::createLLC(const char *Argv0,
 520                                     std::string &Message,
 521                                     const std::string &GCCBinary,
 522                                     const std::vector<std::string> *Args,
 523                                     const std::vector<std::string> *GCCArgs,
 524                                     bool UseIntegratedAssembler) {
 525   std::string LLCPath =
 526     PrependMainExecutablePath("llc", Argv0, (void *)(intptr_t)&createLLC).str();
 527   if (LLCPath.empty()) {
 528     Message = "Cannot find `llc' in executable directory!\n";
 529     return 0;
 530   }
 531
 532   Message = "Found llc: " + LLCPath + "\n";
 533   GCC *gcc = GCC::create(Message, GCCBinary, GCCArgs);
 534   if (!gcc) {
 535     errs() << Message << "\n";
 536     exit(1);
 537   }
 538   return new LLC(LLCPath, gcc, Args, UseIntegratedAssembler);
 539 }
 540
 541 //===---------------------------------------------------------------------===//
 542 // JIT Implementation of AbstractIntepreter interface
 543 //
 544 namespace {
 545   class JIT : public AbstractInterpreter {
 546     std::string LLIPath;          // The path to the LLI executable
 547     std::vector<std::string> ToolArgs; // Args to pass to LLI
 548   public:
 549     JIT(const std::string &Path, const std::vector<std::string> *Args)
 550       : LLIPath(Path) {
 551       ToolArgs.clear ();
 552       if (Args) { ToolArgs = *Args; }
 553     }
 554
 555     virtual int ExecuteProgram(const std::string &Bitcode,
 556                                const std::vector<std::string> &Args,
 557                                const std::string &InputFile,
 558                                const std::string &OutputFile,
 559                                std::string *Error,
 560                                const std::vector<std::string> &GCCArgs =
 561                                  std::vector<std::string>(),
 562                                const std::vector<std::string> &SharedLibs =
 563                                  std::vector<std::string>(),
 564                                unsigned Timeout = 0,
 565                                unsigned MemoryLimit = 0);
 566   };
 567 }
 568
 569 int JIT::ExecuteProgram(const std::string &Bitcode,
 570                         const std::vector<std::string> &Args,
 571                         const std::string &InputFile,
 572                         const std::string &OutputFile,
 573                         std::string *Error,
 574                         const std::vector<std::string> &GCCArgs,
 575                         const std::vector<std::string> &SharedLibs,
 576                         unsigned Timeout,
 577                         unsigned MemoryLimit) {
 578   // Construct a vector of parameters, incorporating those from the command-line
 579   std::vector<const char*> JITArgs;
 580   JITArgs.push_back(LLIPath.c_str());
 581   JITArgs.push_back("-force-interpreter=false");
 582
 583   // Add any extra LLI args.
 584   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 585     JITArgs.push_back(ToolArgs[i].c_str());
 586
 587   for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
 588     JITArgs.push_back("-load");
 589     JITArgs.push_back(SharedLibs[i].c_str());
 590   }
 591   JITArgs.push_back(Bitcode.c_str());
 592   // Add optional parameters to the running program from Argv
 593   for (unsigned i=0, e = Args.size(); i != e; ++i)
 594     JITArgs.push_back(Args[i].c_str());
 595   JITArgs.push_back(0);
 596
 597   outs() << "<jit>"; outs().flush();
 598   DEBUG(errs() << "\nAbout to run:\t";
 599         for (unsigned i=0, e = JITArgs.size()-1; i != e; ++i)
 600           errs() << " " << JITArgs[i];
 601         errs() << "\n";
 602         );
 603   DEBUG(errs() << "\nSending output to " << OutputFile << "\n");
 604   return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
 605       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 606       Timeout, MemoryLimit, Error);
 607 }
 608
 609 /// createJIT - Try to find the LLI executable
 610 ///
 611 AbstractInterpreter *AbstractInterpreter::createJIT(const char *Argv0,
 612                    std::string &Message, const std::vector<std::string> *Args) {
 613   std::string LLIPath =
 614     PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t)&createJIT).str();
 615   if (!LLIPath.empty()) {
 616     Message = "Found lli: " + LLIPath + "\n";
 617     return new JIT(LLIPath, Args);
 618   }
 619
 620   Message = "Cannot find `lli' in executable directory!\n";
 621   return 0;
 622 }
 623
 624 GCC::FileType CBE::OutputCode(const std::string &Bitcode,
 625                               sys::Path &OutputCFile, std::string &Error,
 626                               unsigned Timeout, unsigned MemoryLimit) {
 627   sys::Path uniqueFile(Bitcode+".cbe.c");
 628   std::string ErrMsg;
 629   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 630     errs() << "Error making unique filename: " << ErrMsg << "\n";
 631     exit(1);
 632   }
 633   OutputCFile = uniqueFile;
 634   std::vector<const char *> LLCArgs;
 635   LLCArgs.push_back(LLCPath.c_str());
 636
 637   // Add any extra LLC args.
 638   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 639     LLCArgs.push_back(ToolArgs[i].c_str());
 640
 641   LLCArgs.push_back("-o");
 642   LLCArgs.push_back(OutputCFile.c_str());   // Output to the C file
 643   LLCArgs.push_back("-march=c");            // Output C language
 644   LLCArgs.push_back(Bitcode.c_str());      // This is the input bitcode
 645   LLCArgs.push_back(0);
 646
 647   outs() << "<cbe>"; outs().flush();
 648   DEBUG(errs() << "\nAbout to run:\t";
 649         for (unsigned i = 0, e = LLCArgs.size()-1; i != e; ++i)
 650           errs() << " " << LLCArgs[i];
 651         errs() << "\n";
 652         );
 653   if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
 654                             sys::Path(), Timeout, MemoryLimit))
 655     Error = ProcessFailure(LLCPath, &LLCArgs[0], Timeout, MemoryLimit);
 656   return GCC::CFile;
 657 }
 658
 659 void CBE::compileProgram(const std::string &Bitcode, std::string *Error,
 660                          unsigned Timeout, unsigned MemoryLimit) {
 661   sys::Path OutputCFile;
 662   OutputCode(Bitcode, OutputCFile, *Error, Timeout, MemoryLimit);
 663   OutputCFile.eraseFromDisk();
 664 }
 665
 666 int CBE::ExecuteProgram(const std::string &Bitcode,
 667                         const std::vector<std::string> &Args,
 668                         const std::string &InputFile,
 669                         const std::string &OutputFile,
 670                         std::string *Error,
 671                         const std::vector<std::string> &ArgsForGCC,
 672                         const std::vector<std::string> &SharedLibs,
 673                         unsigned Timeout,
 674                         unsigned MemoryLimit) {
 675   sys::Path OutputCFile;
 676   OutputCode(Bitcode, OutputCFile, *Error, Timeout, MemoryLimit);
 677
 678   FileRemover CFileRemove(OutputCFile.str(), !SaveTemps);
 679
 680   std::vector<std::string> GCCArgs(ArgsForGCC);
 681   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 682
 683   return gcc->ExecuteProgram(OutputCFile.str(), Args, GCC::CFile,
 684                              InputFile, OutputFile, Error, GCCArgs,
 685                              Timeout, MemoryLimit);
 686 }
 687
 688 /// createCBE - Try to find the 'llc' executable
 689 ///
 690 CBE *AbstractInterpreter::createCBE(const char *Argv0,
 691                                     std::string &Message,
 692                                     const std::string &GCCBinary,
 693                                     const std::vector<std::string> *Args,
 694                                     const std::vector<std::string> *GCCArgs) {
 695   sys::Path LLCPath =
 696     PrependMainExecutablePath("llc", Argv0, (void *)(intptr_t)&createCBE);
 697   if (LLCPath.isEmpty()) {
 698     Message =
 699       "Cannot find `llc' in executable directory!\n";
 700     return 0;
 701   }
 702
 703   Message = "Found llc: " + LLCPath.str() + "\n";
 704   GCC *gcc = GCC::create(Message, GCCBinary, GCCArgs);
 705   if (!gcc) {
 706     errs() << Message << "\n";
 707     exit(1);
 708   }
 709   return new CBE(LLCPath, gcc, Args);
 710 }
 711
 712 //===---------------------------------------------------------------------===//
 713 // GCC abstraction
 714 //
 715
 716 static bool IsARMArchitecture(std::vector<const char*> Args) {
 717   for (std::vector<const char*>::const_iterator
 718          I = Args.begin(), E = Args.end(); I != E; ++I) {
 719     if (StringRef(*I).equals_lower("-arch")) {
 720       ++I;
 721       if (I != E && StringRef(*I).substr(0, strlen("arm")).equals_lower("arm"))
 722         return true;
 723     }
 724   }
 725
 726   return false;
 727 }
 728
 729 int GCC::ExecuteProgram(const std::string &ProgramFile,
 730                         const std::vector<std::string> &Args,
 731                         FileType fileType,
 732                         const std::string &InputFile,
 733                         const std::string &OutputFile,
 734                         std::string *Error,
 735                         const std::vector<std::string> &ArgsForGCC,
 736                         unsigned Timeout,
 737                         unsigned MemoryLimit) {
 738   std::vector<const char*> GCCArgs;
 739
 740   GCCArgs.push_back(GCCPath.c_str());
 741
 742   if (TargetTriple.getArch() == Triple::x86)
 743     GCCArgs.push_back("-m32");
 744
 745   for (std::vector<std::string>::const_iterator
 746          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 747     GCCArgs.push_back(I->c_str());
 748
 749   // Specify -x explicitly in case the extension is wonky
 750   if (fileType != ObjectFile) {
 751     GCCArgs.push_back("-x");
 752     if (fileType == CFile) {
 753       GCCArgs.push_back("c");
 754       GCCArgs.push_back("-fno-strict-aliasing");
 755     } else {
 756       GCCArgs.push_back("assembler");
 757
 758       // For ARM architectures we don't want this flag. bugpoint isn't
 759       // explicitly told what architecture it is working on, so we get
 760       // it from gcc flags
 761       if (TargetTriple.isOSDarwin() && !IsARMArchitecture(GCCArgs))
 762         GCCArgs.push_back("-force_cpusubtype_ALL");
 763     }
 764   }
 765
 766   GCCArgs.push_back(ProgramFile.c_str());  // Specify the input filename.
 767
 768   GCCArgs.push_back("-x");
 769   GCCArgs.push_back("none");
 770   GCCArgs.push_back("-o");
 771   sys::Path OutputBinary (ProgramFile+".gcc.exe");
 772   std::string ErrMsg;
 773   if (OutputBinary.makeUnique(true, &ErrMsg)) {
 774     errs() << "Error making unique filename: " << ErrMsg << "\n";
 775     exit(1);
 776   }
 777   GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
 778
 779   // Add any arguments intended for GCC. We locate them here because this is
 780   // most likely -L and -l options that need to come before other libraries but
 781   // after the source. Other options won't be sensitive to placement on the
 782   // command line, so this should be safe.
 783   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 784     GCCArgs.push_back(ArgsForGCC[i].c_str());
 785
 786   GCCArgs.push_back("-lm");                // Hard-code the math library...
 787   GCCArgs.push_back("-O2");                // Optimize the program a bit...
 788 #if defined (HAVE_LINK_R)
 789   GCCArgs.push_back("-Wl,-R.");            // Search this dir for .so files
 790 #endif
 791   if (TargetTriple.getArch() == Triple::sparc)
 792     GCCArgs.push_back("-mcpu=v9");
 793   GCCArgs.push_back(0);                    // NULL terminator
 794
 795   outs() << "<gcc>"; outs().flush();
 796   DEBUG(errs() << "\nAbout to run:\t";
 797         for (unsigned i = 0, e = GCCArgs.size()-1; i != e; ++i)
 798           errs() << " " << GCCArgs[i];
 799         errs() << "\n";
 800         );
 801   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 802         sys::Path())) {
 803     *Error = ProcessFailure(GCCPath, &GCCArgs[0]);
 804     return -1;
 805   }
 806
 807   std::vector<const char*> ProgramArgs;
 808
 809   // Declared here so that the destructor only runs after
 810   // ProgramArgs is used.
 811   std::string Exec;
 812
 813   if (RemoteClientPath.isEmpty())
 814     ProgramArgs.push_back(OutputBinary.c_str());
 815   else {
 816     ProgramArgs.push_back(RemoteClientPath.c_str());
 817     ProgramArgs.push_back(RemoteHost.c_str());
 818     if (!RemoteUser.empty()) {
 819       ProgramArgs.push_back("-l");
 820       ProgramArgs.push_back(RemoteUser.c_str());
 821     }
 822     if (!RemotePort.empty()) {
 823       ProgramArgs.push_back("-p");
 824       ProgramArgs.push_back(RemotePort.c_str());
 825     }
 826     if (!RemoteExtra.empty()) {
 827       ProgramArgs.push_back(RemoteExtra.c_str());
 828     }
 829
 830     // Full path to the binary. We need to cd to the exec directory because
 831     // there is a dylib there that the exec expects to find in the CWD
 832     char* env_pwd = getenv("PWD");
 833     Exec = "cd ";
 834     Exec += env_pwd;
 835     Exec += "; ./";
 836     Exec += OutputBinary.c_str();
 837     ProgramArgs.push_back(Exec.c_str());
 838   }
 839
 840   // Add optional parameters to the running program from Argv
 841   for (unsigned i = 0, e = Args.size(); i != e; ++i)
 842     ProgramArgs.push_back(Args[i].c_str());
 843   ProgramArgs.push_back(0);                // NULL terminator
 844
 845   // Now that we have a binary, run it!
 846   outs() << "<program>"; outs().flush();
 847   DEBUG(errs() << "\nAbout to run:\t";
 848         for (unsigned i = 0, e = ProgramArgs.size()-1; i != e; ++i)
 849           errs() << " " << ProgramArgs[i];
 850         errs() << "\n";
 851         );
 852
 853   FileRemover OutputBinaryRemover(OutputBinary.str(), !SaveTemps);
 854
 855   if (RemoteClientPath.isEmpty()) {
 856     DEBUG(errs() << "<run locally>");
 857     int ExitCode = RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
 858         sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 859         Timeout, MemoryLimit, Error);
 860     // Treat a signal (usually SIGSEGV) or timeout as part of the program output
 861     // so that crash-causing miscompilation is handled seamlessly.
 862     if (ExitCode < -1) {
 863       std::ofstream outFile(OutputFile.c_str(), std::ios_base::app);
 864       outFile << *Error << '\n';
 865       outFile.close();
 866       Error->clear();
 867     }
 868     return ExitCode;
 869   } else {
 870     outs() << "<run remotely>"; outs().flush();
 871     return RunProgramRemotelyWithTimeout(sys::Path(RemoteClientPath),
 872         &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 873         sys::Path(OutputFile), Timeout, MemoryLimit);
 874   }
 875 }
 876
 877 int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType,
 878                           std::string &OutputFile,
 879                           const std::vector<std::string> &ArgsForGCC,
 880                           std::string &Error) {
 881   sys::Path uniqueFilename(InputFile+LTDL_SHLIB_EXT);
 882   std::string ErrMsg;
 883   if (uniqueFilename.makeUnique(true, &ErrMsg)) {
 884     errs() << "Error making unique filename: " << ErrMsg << "\n";
 885     exit(1);
 886   }
 887   OutputFile = uniqueFilename.str();
 888
 889   std::vector<const char*> GCCArgs;
 890
 891   GCCArgs.push_back(GCCPath.c_str());
 892
 893   if (TargetTriple.getArch() == Triple::x86)
 894     GCCArgs.push_back("-m32");
 895
 896   for (std::vector<std::string>::const_iterator
 897          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 898     GCCArgs.push_back(I->c_str());
 899
 900   // Compile the C/asm file into a shared object
 901   if (fileType != ObjectFile) {
 902     GCCArgs.push_back("-x");
 903     GCCArgs.push_back(fileType == AsmFile ? "assembler" : "c");
 904   }
 905   GCCArgs.push_back("-fno-strict-aliasing");
 906   GCCArgs.push_back(InputFile.c_str());   // Specify the input filename.
 907   GCCArgs.push_back("-x");
 908   GCCArgs.push_back("none");
 909   if (TargetTriple.getArch() == Triple::sparc)
 910     GCCArgs.push_back("-G");       // Compile a shared library, `-G' for Sparc
 911   else if (TargetTriple.isOSDarwin()) {
 912     // link all source files into a single module in data segment, rather than
 913     // generating blocks. dynamic_lookup requires that you set
 914     // MACOSX_DEPLOYMENT_TARGET=10.3 in your env.  FIXME: it would be better for
 915     // bugpoint to just pass that in the environment of GCC.
 916     GCCArgs.push_back("-single_module");
 917     GCCArgs.push_back("-dynamiclib");   // `-dynamiclib' for MacOS X/PowerPC
 918     GCCArgs.push_back("-undefined");
 919     GCCArgs.push_back("dynamic_lookup");
 920   } else
 921     GCCArgs.push_back("-shared");  // `-shared' for Linux/X86, maybe others
 922
 923   if ((TargetTriple.getArch() == Triple::alpha) ||
 924       (TargetTriple.getArch() == Triple::x86_64))
 925     GCCArgs.push_back("-fPIC");   // Requires shared objs to contain PIC
 926
 927   if (TargetTriple.getArch() == Triple::sparc)
 928     GCCArgs.push_back("-mcpu=v9");
 929
 930   GCCArgs.push_back("-o");
 931   GCCArgs.push_back(OutputFile.c_str()); // Output to the right filename.
 932   GCCArgs.push_back("-O2");              // Optimize the program a bit.
 933
 934
 935
 936   // Add any arguments intended for GCC. We locate them here because this is
 937   // most likely -L and -l options that need to come before other libraries but
 938   // after the source. Other options won't be sensitive to placement on the
 939   // command line, so this should be safe.
 940   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 941     GCCArgs.push_back(ArgsForGCC[i].c_str());
 942   GCCArgs.push_back(0);                    // NULL terminator
 943
 944
 945
 946   outs() << "<gcc>"; outs().flush();
 947   DEBUG(errs() << "\nAbout to run:\t";
 948         for (unsigned i = 0, e = GCCArgs.size()-1; i != e; ++i)
 949           errs() << " " << GCCArgs[i];
 950         errs() << "\n";
 951         );
 952   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 953                             sys::Path())) {
 954     Error = ProcessFailure(GCCPath, &GCCArgs[0]);
 955     return 1;
 956   }
 957   return 0;
 958 }
 959
 960 /// create - Try to find the `gcc' executable
 961 ///
 962 GCC *GCC::create(std::string &Message,
 963                  const std::string &GCCBinary,
 964                  const std::vector<std::string> *Args) {
 965   sys::Path GCCPath = sys::Program::FindProgramByName(GCCBinary);
 966   if (GCCPath.isEmpty()) {
 967     Message = "Cannot find `"+ GCCBinary +"' in PATH!\n";
 968     return 0;
 969   }
 970
 971   sys::Path RemoteClientPath;
 972   if (!RemoteClient.empty())
 973     RemoteClientPath = sys::Program::FindProgramByName(RemoteClient);
 974
 975   Message = "Found gcc: " + GCCPath.str() + "\n";
 976   return new GCC(GCCPath, RemoteClientPath, Args);
 977 }