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 {
  26   cl::opt<std::string>
  27   RemoteClient("remote-client",
  28                cl::desc("Remote execution client (rsh/ssh)"));
  29
  30   cl::opt<std::string>
  31   RemoteHost("remote-host",
  32              cl::desc("Remote execution (rsh/ssh) host"));
  33
  34   cl::opt<std::string>
  35   RemotePort("remote-port",
  36              cl::desc("Remote execution (rsh/ssh) port"));
  37
  38   cl::opt<std::string>
  39   RemoteUser("remote-user",
  40              cl::desc("Remote execution (rsh/ssh) user id"));
  41
  42   cl::opt<std::string>
  43   RemoteExtra("remote-extra-options",
  44           cl::desc("Remote execution (rsh/ssh) extra options"));
  45 }
  46
  47 ToolExecutionError::~ToolExecutionError() throw() { }
  48
  49 /// RunProgramWithTimeout - This function provides an alternate interface to the
  50 /// sys::Program::ExecuteAndWait interface.
  51 /// @see sys:Program::ExecuteAndWait
  52 static int RunProgramWithTimeout(const sys::Path &ProgramPath,
  53                                  const char **Args,
  54                                  const sys::Path &StdInFile,
  55                                  const sys::Path &StdOutFile,
  56                                  const sys::Path &StdErrFile,
  57                                  unsigned NumSeconds = 0,
  58                                  unsigned MemoryLimit = 0) {
  59   const sys::Path* redirects[3];
  60   redirects[0] = &StdInFile;
  61   redirects[1] = &StdOutFile;
  62   redirects[2] = &StdErrFile;
  63
  64   if (0) {
  65     errs() << "RUN:";
  66     for (unsigned i = 0; Args[i]; ++i)
  67       errs() << " " << Args[i];
  68     errs() << "\n";
  69   }
  70
  71   return
  72     sys::Program::ExecuteAndWait(ProgramPath, Args, 0, redirects,
  73                                  NumSeconds, MemoryLimit);
  74 }
  75
  76
  77
  78 static void ProcessFailure(sys::Path ProgPath, const char** Args) {
  79   std::ostringstream OS;
  80   OS << "\nError running tool:\n ";
  81   for (const char **Arg = Args; *Arg; ++Arg)
  82     OS << " " << *Arg;
  83   OS << "\n";
  84
  85   // Rerun the compiler, capturing any error messages to print them.
  86   sys::Path ErrorFilename("bugpoint.program_error_messages");
  87   std::string ErrMsg;
  88   if (ErrorFilename.makeUnique(true, &ErrMsg)) {
  89     errs() << "Error making unique filename: " << ErrMsg << "\n";
  90     exit(1);
  91   }
  92   RunProgramWithTimeout(ProgPath, Args, sys::Path(""), ErrorFilename,
  93                         ErrorFilename); // FIXME: check return code ?
  94
  95   // Print out the error messages generated by GCC if possible...
  96   std::ifstream ErrorFile(ErrorFilename.c_str());
  97   if (ErrorFile) {
  98     std::copy(std::istreambuf_iterator<char>(ErrorFile),
  99               std::istreambuf_iterator<char>(),
 100               std::ostreambuf_iterator<char>(OS));
 101     ErrorFile.close();
 102   }
 103
 104   ErrorFilename.eraseFromDisk();
 105   throw ToolExecutionError(OS.str());
 106 }
 107
 108 //===---------------------------------------------------------------------===//
 109 // LLI Implementation of AbstractIntepreter interface
 110 //
 111 namespace {
 112   class LLI : public AbstractInterpreter {
 113     std::string LLIPath;          // The path to the LLI executable
 114     std::vector<std::string> ToolArgs; // Args to pass to LLI
 115   public:
 116     LLI(const std::string &Path, const std::vector<std::string> *Args)
 117       : LLIPath(Path) {
 118       ToolArgs.clear ();
 119       if (Args) { ToolArgs = *Args; }
 120     }
 121
 122     virtual int ExecuteProgram(const std::string &Bitcode,
 123                                const std::vector<std::string> &Args,
 124                                const std::string &InputFile,
 125                                const std::string &OutputFile,
 126                                const std::vector<std::string> &GCCArgs,
 127                                const std::vector<std::string> &SharedLibs =
 128                                std::vector<std::string>(),
 129                                unsigned Timeout = 0,
 130                                unsigned MemoryLimit = 0);
 131   };
 132 }
 133
 134 int LLI::ExecuteProgram(const std::string &Bitcode,
 135                         const std::vector<std::string> &Args,
 136                         const std::string &InputFile,
 137                         const std::string &OutputFile,
 138                         const std::vector<std::string> &GCCArgs,
 139                         const std::vector<std::string> &SharedLibs,
 140                         unsigned Timeout,
 141                         unsigned MemoryLimit) {
 142   if (!SharedLibs.empty())
 143     throw ToolExecutionError("LLI currently does not support "
 144                              "loading shared libraries.");
 145
 146   std::vector<const char*> LLIArgs;
 147   LLIArgs.push_back(LLIPath.c_str());
 148   LLIArgs.push_back("-force-interpreter=true");
 149
 150   // Add any extra LLI args.
 151   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 152     LLIArgs.push_back(ToolArgs[i].c_str());
 153
 154   LLIArgs.push_back(Bitcode.c_str());
 155   // Add optional parameters to the running program from Argv
 156   for (unsigned i=0, e = Args.size(); i != e; ++i)
 157     LLIArgs.push_back(Args[i].c_str());
 158   LLIArgs.push_back(0);
 159
 160   outs() << "<lli>"; outs().flush();
 161   DEBUG(errs() << "\nAbout to run:\t";
 162         for (unsigned i=0, e = LLIArgs.size()-1; i != e; ++i)
 163           errs() << " " << LLIArgs[i];
 164         errs() << "\n";
 165         );
 166   return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
 167       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 168       Timeout, MemoryLimit);
 169 }
 170
 171 // LLI create method - Try to find the LLI executable
 172 AbstractInterpreter *AbstractInterpreter::createLLI(const std::string &ProgPath,
 173                                                     std::string &Message,
 174                                      const std::vector<std::string> *ToolArgs) {
 175   std::string LLIPath = FindExecutable("lli", ProgPath).toString();
 176   if (!LLIPath.empty()) {
 177     Message = "Found lli: " + LLIPath + "\n";
 178     return new LLI(LLIPath, ToolArgs);
 179   }
 180
 181   Message = "Cannot find `lli' in executable directory or PATH!\n";
 182   return 0;
 183 }
 184
 185 //===---------------------------------------------------------------------===//
 186 // Custom execution command implementation of AbstractIntepreter interface
 187 //
 188 // Allows using a custom command for executing the bitcode, thus allows,
 189 // for example, to invoke a cross compiler for code generation followed by
 190 // a simulator that executes the generated binary.
 191 namespace {
 192   class CustomExecutor : public AbstractInterpreter {
 193     std::string ExecutionCommand;
 194     std::vector<std::string> ExecutorArgs;
 195   public:
 196     CustomExecutor(
 197       const std::string &ExecutionCmd, std::vector<std::string> ExecArgs) :
 198       ExecutionCommand(ExecutionCmd), ExecutorArgs(ExecArgs) {}
 199
 200     virtual int ExecuteProgram(const std::string &Bitcode,
 201                                const std::vector<std::string> &Args,
 202                                const std::string &InputFile,
 203                                const std::string &OutputFile,
 204                                const std::vector<std::string> &GCCArgs,
 205                                const std::vector<std::string> &SharedLibs =
 206                                std::vector<std::string>(),
 207                                unsigned Timeout = 0,
 208                                unsigned MemoryLimit = 0);
 209   };
 210 }
 211
 212 int CustomExecutor::ExecuteProgram(const std::string &Bitcode,
 213                         const std::vector<std::string> &Args,
 214                         const std::string &InputFile,
 215                         const std::string &OutputFile,
 216                         const std::vector<std::string> &GCCArgs,
 217                         const std::vector<std::string> &SharedLibs,
 218                         unsigned Timeout,
 219                         unsigned MemoryLimit) {
 220
 221   std::vector<const char*> ProgramArgs;
 222   ProgramArgs.push_back(ExecutionCommand.c_str());
 223
 224   for (std::size_t i = 0; i < ExecutorArgs.size(); ++i)
 225     ProgramArgs.push_back(ExecutorArgs.at(i).c_str());
 226   ProgramArgs.push_back(Bitcode.c_str());
 227   ProgramArgs.push_back(0);
 228
 229   // Add optional parameters to the running program from Argv
 230   for (unsigned i=0, e = Args.size(); i != e; ++i)
 231     ProgramArgs.push_back(Args[i].c_str());
 232
 233   return RunProgramWithTimeout(
 234     sys::Path(ExecutionCommand),
 235     &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 236     sys::Path(OutputFile), Timeout, MemoryLimit);
 237 }
 238
 239 // Custom execution environment create method, takes the execution command
 240 // as arguments
 241 AbstractInterpreter *AbstractInterpreter::createCustom(
 242                     const std::string &ProgramPath,
 243                     std::string &Message,
 244                     const std::string &ExecCommandLine) {
 245
 246   std::string Command = "";
 247   std::vector<std::string> Args;
 248   std::string delimiters = " ";
 249
 250   // Tokenize the ExecCommandLine to the command and the args to allow
 251   // defining a full command line as the command instead of just the
 252   // executed program. We cannot just pass the whole string after the command
 253   // as a single argument because then program sees only a single
 254   // command line argument (with spaces in it: "foo bar" instead
 255   // of "foo" and "bar").
 256
 257   // code borrowed from:
 258   // http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html
 259   std::string::size_type lastPos =
 260     ExecCommandLine.find_first_not_of(delimiters, 0);
 261   std::string::size_type pos =
 262     ExecCommandLine.find_first_of(delimiters, lastPos);
 263
 264   while (std::string::npos != pos || std::string::npos != lastPos) {
 265     std::string token = ExecCommandLine.substr(lastPos, pos - lastPos);
 266     if (Command == "")
 267        Command = token;
 268     else
 269        Args.push_back(token);
 270     // Skip delimiters.  Note the "not_of"
 271     lastPos = ExecCommandLine.find_first_not_of(delimiters, pos);
 272     // Find next "non-delimiter"
 273     pos = ExecCommandLine.find_first_of(delimiters, lastPos);
 274   }
 275
 276   std::string CmdPath = FindExecutable(Command, ProgramPath).toString();
 277   if (CmdPath.empty()) {
 278     Message =
 279       std::string("Cannot find '") + Command +
 280       "' in executable directory or PATH!\n";
 281     return 0;
 282   }
 283
 284   Message = "Found command in: " + CmdPath + "\n";
 285
 286   return new CustomExecutor(CmdPath, Args);
 287 }
 288
 289 //===----------------------------------------------------------------------===//
 290 // LLC Implementation of AbstractIntepreter interface
 291 //
 292 GCC::FileType LLC::OutputCode(const std::string &Bitcode,
 293                               sys::Path &OutputAsmFile) {
 294   sys::Path uniqueFile(Bitcode+".llc.s");
 295   std::string ErrMsg;
 296   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 297     errs() << "Error making unique filename: " << ErrMsg << "\n";
 298     exit(1);
 299   }
 300   OutputAsmFile = uniqueFile;
 301   std::vector<const char *> LLCArgs;
 302   LLCArgs.push_back (LLCPath.c_str());
 303
 304   // Add any extra LLC args.
 305   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 306     LLCArgs.push_back(ToolArgs[i].c_str());
 307
 308   LLCArgs.push_back ("-o");
 309   LLCArgs.push_back (OutputAsmFile.c_str()); // Output to the Asm file
 310   LLCArgs.push_back ("-f");                  // Overwrite as necessary...
 311   LLCArgs.push_back (Bitcode.c_str());      // This is the input bitcode
 312   LLCArgs.push_back (0);
 313
 314   outs() << "<llc>"; outs().flush();
 315   DEBUG(errs() << "\nAbout to run:\t";
 316         for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
 317           errs() << " " << LLCArgs[i];
 318         errs() << "\n";
 319         );
 320   if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
 321                             sys::Path(), sys::Path(), sys::Path()))
 322     ProcessFailure(sys::Path(LLCPath), &LLCArgs[0]);
 323
 324   return GCC::AsmFile;
 325 }
 326
 327 void LLC::compileProgram(const std::string &Bitcode) {
 328   sys::Path OutputAsmFile;
 329   OutputCode(Bitcode, OutputAsmFile);
 330   OutputAsmFile.eraseFromDisk();
 331 }
 332
 333 int LLC::ExecuteProgram(const std::string &Bitcode,
 334                         const std::vector<std::string> &Args,
 335                         const std::string &InputFile,
 336                         const std::string &OutputFile,
 337                         const std::vector<std::string> &ArgsForGCC,
 338                         const std::vector<std::string> &SharedLibs,
 339                         unsigned Timeout,
 340                         unsigned MemoryLimit) {
 341
 342   sys::Path OutputAsmFile;
 343   OutputCode(Bitcode, OutputAsmFile);
 344   FileRemover OutFileRemover(OutputAsmFile);
 345
 346   std::vector<std::string> GCCArgs(ArgsForGCC);
 347   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 348   GCCArgs.insert(GCCArgs.end(), gccArgs.begin(), gccArgs.end());
 349
 350   // Assuming LLC worked, compile the result with GCC and run it.
 351   return gcc->ExecuteProgram(OutputAsmFile.toString(), Args, GCC::AsmFile,
 352                              InputFile, OutputFile, GCCArgs,
 353                              Timeout, MemoryLimit);
 354 }
 355
 356 /// createLLC - Try to find the LLC executable
 357 ///
 358 LLC *AbstractInterpreter::createLLC(const std::string &ProgramPath,
 359                                     std::string &Message,
 360                                     const std::vector<std::string> *Args,
 361                                     const std::vector<std::string> *GCCArgs) {
 362   std::string LLCPath = FindExecutable("llc", ProgramPath).toString();
 363   if (LLCPath.empty()) {
 364     Message = "Cannot find `llc' in executable directory or PATH!\n";
 365     return 0;
 366   }
 367
 368   Message = "Found llc: " + LLCPath + "\n";
 369   GCC *gcc = GCC::create(ProgramPath, Message, GCCArgs);
 370   if (!gcc) {
 371     errs() << Message << "\n";
 372     exit(1);
 373   }
 374   return new LLC(LLCPath, gcc, Args, GCCArgs);
 375 }
 376
 377 //===---------------------------------------------------------------------===//
 378 // JIT Implementation of AbstractIntepreter interface
 379 //
 380 namespace {
 381   class JIT : public AbstractInterpreter {
 382     std::string LLIPath;          // The path to the LLI executable
 383     std::vector<std::string> ToolArgs; // Args to pass to LLI
 384   public:
 385     JIT(const std::string &Path, const std::vector<std::string> *Args)
 386       : LLIPath(Path) {
 387       ToolArgs.clear ();
 388       if (Args) { ToolArgs = *Args; }
 389     }
 390
 391     virtual int ExecuteProgram(const std::string &Bitcode,
 392                                const std::vector<std::string> &Args,
 393                                const std::string &InputFile,
 394                                const std::string &OutputFile,
 395                                const std::vector<std::string> &GCCArgs =
 396                                  std::vector<std::string>(),
 397                                const std::vector<std::string> &SharedLibs =
 398                                  std::vector<std::string>(),
 399                                unsigned Timeout =0,
 400                                unsigned MemoryLimit =0);
 401   };
 402 }
 403
 404 int JIT::ExecuteProgram(const std::string &Bitcode,
 405                         const std::vector<std::string> &Args,
 406                         const std::string &InputFile,
 407                         const std::string &OutputFile,
 408                         const std::vector<std::string> &GCCArgs,
 409                         const std::vector<std::string> &SharedLibs,
 410                         unsigned Timeout,
 411                         unsigned MemoryLimit) {
 412   // Construct a vector of parameters, incorporating those from the command-line
 413   std::vector<const char*> JITArgs;
 414   JITArgs.push_back(LLIPath.c_str());
 415   JITArgs.push_back("-force-interpreter=false");
 416
 417   // Add any extra LLI args.
 418   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 419     JITArgs.push_back(ToolArgs[i].c_str());
 420
 421   for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
 422     JITArgs.push_back("-load");
 423     JITArgs.push_back(SharedLibs[i].c_str());
 424   }
 425   JITArgs.push_back(Bitcode.c_str());
 426   // Add optional parameters to the running program from Argv
 427   for (unsigned i=0, e = Args.size(); i != e; ++i)
 428     JITArgs.push_back(Args[i].c_str());
 429   JITArgs.push_back(0);
 430
 431   outs() << "<jit>"; outs().flush();
 432   DEBUG(errs() << "\nAbout to run:\t";
 433         for (unsigned i=0, e = JITArgs.size()-1; i != e; ++i)
 434           errs() << " " << JITArgs[i];
 435         errs() << "\n";
 436         );
 437   DEBUG(errs() << "\nSending output to " << OutputFile << "\n");
 438   return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
 439       sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 440       Timeout, MemoryLimit);
 441 }
 442
 443 /// createJIT - Try to find the LLI executable
 444 ///
 445 AbstractInterpreter *AbstractInterpreter::createJIT(const std::string &ProgPath,
 446                    std::string &Message, const std::vector<std::string> *Args) {
 447   std::string LLIPath = FindExecutable("lli", ProgPath).toString();
 448   if (!LLIPath.empty()) {
 449     Message = "Found lli: " + LLIPath + "\n";
 450     return new JIT(LLIPath, Args);
 451   }
 452
 453   Message = "Cannot find `lli' in executable directory or PATH!\n";
 454   return 0;
 455 }
 456
 457 GCC::FileType CBE::OutputCode(const std::string &Bitcode,
 458                               sys::Path &OutputCFile) {
 459   sys::Path uniqueFile(Bitcode+".cbe.c");
 460   std::string ErrMsg;
 461   if (uniqueFile.makeUnique(true, &ErrMsg)) {
 462     errs() << "Error making unique filename: " << ErrMsg << "\n";
 463     exit(1);
 464   }
 465   OutputCFile = uniqueFile;
 466   std::vector<const char *> LLCArgs;
 467   LLCArgs.push_back (LLCPath.c_str());
 468
 469   // Add any extra LLC args.
 470   for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
 471     LLCArgs.push_back(ToolArgs[i].c_str());
 472
 473   LLCArgs.push_back ("-o");
 474   LLCArgs.push_back (OutputCFile.c_str());   // Output to the C file
 475   LLCArgs.push_back ("-march=c");            // Output C language
 476   LLCArgs.push_back ("-f");                  // Overwrite as necessary...
 477   LLCArgs.push_back (Bitcode.c_str());      // This is the input bitcode
 478   LLCArgs.push_back (0);
 479
 480   outs() << "<cbe>"; outs().flush();
 481   DEBUG(errs() << "\nAbout to run:\t";
 482         for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
 483           errs() << " " << LLCArgs[i];
 484         errs() << "\n";
 485         );
 486   if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
 487                             sys::Path()))
 488     ProcessFailure(LLCPath, &LLCArgs[0]);
 489   return GCC::CFile;
 490 }
 491
 492 void CBE::compileProgram(const std::string &Bitcode) {
 493   sys::Path OutputCFile;
 494   OutputCode(Bitcode, OutputCFile);
 495   OutputCFile.eraseFromDisk();
 496 }
 497
 498 int CBE::ExecuteProgram(const std::string &Bitcode,
 499                         const std::vector<std::string> &Args,
 500                         const std::string &InputFile,
 501                         const std::string &OutputFile,
 502                         const std::vector<std::string> &ArgsForGCC,
 503                         const std::vector<std::string> &SharedLibs,
 504                         unsigned Timeout,
 505                         unsigned MemoryLimit) {
 506   sys::Path OutputCFile;
 507   OutputCode(Bitcode, OutputCFile);
 508
 509   FileRemover CFileRemove(OutputCFile);
 510
 511   std::vector<std::string> GCCArgs(ArgsForGCC);
 512   GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
 513
 514   return gcc->ExecuteProgram(OutputCFile.toString(), Args, GCC::CFile,
 515                              InputFile, OutputFile, GCCArgs,
 516                              Timeout, MemoryLimit);
 517 }
 518
 519 /// createCBE - Try to find the 'llc' executable
 520 ///
 521 CBE *AbstractInterpreter::createCBE(const std::string &ProgramPath,
 522                                     std::string &Message,
 523                                     const std::vector<std::string> *Args,
 524                                     const std::vector<std::string> *GCCArgs) {
 525   sys::Path LLCPath = FindExecutable("llc", ProgramPath);
 526   if (LLCPath.isEmpty()) {
 527     Message =
 528       "Cannot find `llc' in executable directory or PATH!\n";
 529     return 0;
 530   }
 531
 532   Message = "Found llc: " + LLCPath.toString() + "\n";
 533   GCC *gcc = GCC::create(ProgramPath, Message, GCCArgs);
 534   if (!gcc) {
 535     errs() << Message << "\n";
 536     exit(1);
 537   }
 538   return new CBE(LLCPath, gcc, Args);
 539 }
 540
 541 //===---------------------------------------------------------------------===//
 542 // GCC abstraction
 543 //
 544
 545 #ifdef __APPLE__
 546 static bool
 547 IsARMArchitecture(std::vector<std::string> Args)
 548 {
 549   for (std::vector<std::string>::const_iterator
 550          I = Args.begin(), E = Args.end(); I != E; ++I) {
 551     if (!strcasecmp(I->c_str(), "-arch")) {
 552       ++I;
 553       if ((I != E) && !strncasecmp(I->c_str(), "arm", strlen("arm"))) {
 554         return true;
 555       }
 556     }
 557   }
 558
 559   return false;
 560 }
 561 #endif
 562
 563 int GCC::ExecuteProgram(const std::string &ProgramFile,
 564                         const std::vector<std::string> &Args,
 565                         FileType fileType,
 566                         const std::string &InputFile,
 567                         const std::string &OutputFile,
 568                         const std::vector<std::string> &ArgsForGCC,
 569                         unsigned Timeout,
 570                         unsigned MemoryLimit) {
 571   std::vector<const char*> GCCArgs;
 572
 573   GCCArgs.push_back(GCCPath.c_str());
 574
 575   for (std::vector<std::string>::const_iterator
 576          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 577     GCCArgs.push_back(I->c_str());
 578
 579   // Specify -x explicitly in case the extension is wonky
 580   GCCArgs.push_back("-x");
 581   if (fileType == CFile) {
 582     GCCArgs.push_back("c");
 583     GCCArgs.push_back("-fno-strict-aliasing");
 584   } else {
 585     GCCArgs.push_back("assembler");
 586 #ifdef __APPLE__
 587     // For ARM architectures we don't want this flag. bugpoint isn't
 588     // explicitly told what architecture it is working on, so we get
 589     // it from gcc flags
 590     if (!IsARMArchitecture(ArgsForGCC))
 591       GCCArgs.push_back("-force_cpusubtype_ALL");
 592 #endif
 593   }
 594   GCCArgs.push_back(ProgramFile.c_str());  // Specify the input filename...
 595   GCCArgs.push_back("-x");
 596   GCCArgs.push_back("none");
 597   GCCArgs.push_back("-o");
 598   sys::Path OutputBinary (ProgramFile+".gcc.exe");
 599   std::string ErrMsg;
 600   if (OutputBinary.makeUnique(true, &ErrMsg)) {
 601     errs() << "Error making unique filename: " << ErrMsg << "\n";
 602     exit(1);
 603   }
 604   GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
 605
 606   // Add any arguments intended for GCC. We locate them here because this is
 607   // most likely -L and -l options that need to come before other libraries but
 608   // after the source. Other options won't be sensitive to placement on the
 609   // command line, so this should be safe.
 610   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 611     GCCArgs.push_back(ArgsForGCC[i].c_str());
 612
 613   GCCArgs.push_back("-lm");                // Hard-code the math library...
 614   GCCArgs.push_back("-O2");                // Optimize the program a bit...
 615 #if defined (HAVE_LINK_R)
 616   GCCArgs.push_back("-Wl,-R.");            // Search this dir for .so files
 617 #endif
 618 #ifdef __sparc__
 619   GCCArgs.push_back("-mcpu=v9");
 620 #endif
 621   GCCArgs.push_back(0);                    // NULL terminator
 622
 623   outs() << "<gcc>"; outs().flush();
 624   DEBUG(errs() << "\nAbout to run:\t";
 625         for (unsigned i=0, e = GCCArgs.size()-1; i != e; ++i)
 626           errs() << " " << GCCArgs[i];
 627         errs() << "\n";
 628         );
 629   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 630         sys::Path())) {
 631     ProcessFailure(GCCPath, &GCCArgs[0]);
 632     exit(1);
 633   }
 634
 635   std::vector<const char*> ProgramArgs;
 636
 637   std::string Exec;
 638   if (RemoteClientPath.isEmpty())
 639     ProgramArgs.push_back(OutputBinary.c_str());
 640   else {
 641     ProgramArgs.push_back(RemoteClientPath.c_str());
 642     ProgramArgs.push_back(RemoteHost.c_str());
 643     ProgramArgs.push_back("-l");
 644     ProgramArgs.push_back(RemoteUser.c_str());
 645     if (!RemotePort.empty()) {
 646       ProgramArgs.push_back("-p");
 647       ProgramArgs.push_back(RemotePort.c_str());
 648     }
 649     if (!RemoteExtra.empty()) {
 650       ProgramArgs.push_back(RemoteExtra.c_str());
 651     }
 652
 653     // Full path to the binary
 654     char* env_pwd = getenv("PWD");
 655     Exec += env_pwd;
 656     Exec += "/";
 657     Exec += OutputBinary.c_str();
 658     ProgramArgs.push_back(Exec.c_str());
 659   }
 660
 661   // Add optional parameters to the running program from Argv
 662   for (unsigned i=0, e = Args.size(); i != e; ++i)
 663     ProgramArgs.push_back(Args[i].c_str());
 664   ProgramArgs.push_back(0);                // NULL terminator
 665
 666   // Now that we have a binary, run it!
 667   outs() << "<program>"; outs().flush();
 668   DEBUG(errs() << "\nAbout to run:\t";
 669         for (unsigned i=0, e = ProgramArgs.size()-1; i != e; ++i)
 670           errs() << " " << ProgramArgs[i];
 671         errs() << "\n";
 672         );
 673
 674   FileRemover OutputBinaryRemover(OutputBinary);
 675
 676   if (RemoteClientPath.isEmpty()) {
 677     DEBUG(errs() << "<run locally>";);
 678     return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
 679         sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
 680         Timeout, MemoryLimit);
 681   } else {
 682     outs() << "<run remotely>"; outs().flush();
 683     int RemoteClientStatus = RunProgramWithTimeout(sys::Path(RemoteClientPath),
 684         &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
 685         sys::Path(OutputFile), Timeout, MemoryLimit);
 686     if (RemoteClientStatus != 0) {
 687       errs() << "Remote Client failed with an error: " <<
 688         RemoteClientStatus << ".\n";
 689     }
 690   }
 691
 692   return 0;
 693 }
 694
 695 int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType,
 696                           std::string &OutputFile,
 697                           const std::vector<std::string> &ArgsForGCC) {
 698   sys::Path uniqueFilename(InputFile+LTDL_SHLIB_EXT);
 699   std::string ErrMsg;
 700   if (uniqueFilename.makeUnique(true, &ErrMsg)) {
 701     errs() << "Error making unique filename: " << ErrMsg << "\n";
 702     exit(1);
 703   }
 704   OutputFile = uniqueFilename.toString();
 705
 706   std::vector<const char*> GCCArgs;
 707
 708   GCCArgs.push_back(GCCPath.c_str());
 709
 710   for (std::vector<std::string>::const_iterator
 711          I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
 712     GCCArgs.push_back(I->c_str());
 713
 714   // Compile the C/asm file into a shared object
 715   GCCArgs.push_back("-x");
 716   GCCArgs.push_back(fileType == AsmFile ? "assembler" : "c");
 717   GCCArgs.push_back("-fno-strict-aliasing");
 718   GCCArgs.push_back(InputFile.c_str());   // Specify the input filename.
 719   GCCArgs.push_back("-x");
 720   GCCArgs.push_back("none");
 721 #if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
 722   GCCArgs.push_back("-G");       // Compile a shared library, `-G' for Sparc
 723 #elif defined(__APPLE__)
 724   // link all source files into a single module in data segment, rather than
 725   // generating blocks. dynamic_lookup requires that you set
 726   // MACOSX_DEPLOYMENT_TARGET=10.3 in your env.  FIXME: it would be better for
 727   // bugpoint to just pass that in the environment of GCC.
 728   GCCArgs.push_back("-single_module");
 729   GCCArgs.push_back("-dynamiclib");   // `-dynamiclib' for MacOS X/PowerPC
 730   GCCArgs.push_back("-undefined");
 731   GCCArgs.push_back("dynamic_lookup");
 732 #else
 733   GCCArgs.push_back("-shared");  // `-shared' for Linux/X86, maybe others
 734 #endif
 735
 736 #if defined(__ia64__) || defined(__alpha__) || defined(__amd64__)
 737   GCCArgs.push_back("-fPIC");   // Requires shared objs to contain PIC
 738 #endif
 739 #ifdef __sparc__
 740   GCCArgs.push_back("-mcpu=v9");
 741 #endif
 742   GCCArgs.push_back("-o");
 743   GCCArgs.push_back(OutputFile.c_str()); // Output to the right filename.
 744   GCCArgs.push_back("-O2");              // Optimize the program a bit.
 745
 746
 747
 748   // Add any arguments intended for GCC. We locate them here because this is
 749   // most likely -L and -l options that need to come before other libraries but
 750   // after the source. Other options won't be sensitive to placement on the
 751   // command line, so this should be safe.
 752   for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
 753     GCCArgs.push_back(ArgsForGCC[i].c_str());
 754   GCCArgs.push_back(0);                    // NULL terminator
 755
 756
 757
 758   outs() << "<gcc>"; outs().flush();
 759   DEBUG(errs() << "\nAbout to run:\t";
 760         for (unsigned i=0, e = GCCArgs.size()-1; i != e; ++i)
 761           errs() << " " << GCCArgs[i];
 762         errs() << "\n";
 763         );
 764   if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
 765                             sys::Path())) {
 766     ProcessFailure(GCCPath, &GCCArgs[0]);
 767     return 1;
 768   }
 769   return 0;
 770 }
 771
 772 /// create - Try to find the `gcc' executable
 773 ///
 774 GCC *GCC::create(const std::string &ProgramPath, std::string &Message,
 775                  const std::vector<std::string> *Args) {
 776   sys::Path GCCPath = FindExecutable("gcc", ProgramPath);
 777   if (GCCPath.isEmpty()) {
 778     Message = "Cannot find `gcc' in executable directory or PATH!\n";
 779     return 0;
 780   }
 781
 782   sys::Path RemoteClientPath;
 783   if (!RemoteClient.empty())
 784     RemoteClientPath = FindExecutable(RemoteClient.c_str(), ProgramPath);
 785
 786   Message = "Found gcc: " + GCCPath.toString() + "\n";
 787   return new GCC(GCCPath, RemoteClientPath, Args);
 788 }