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