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