1 //===-- ToolRunner.cpp ----------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the interfaces described in the ToolRunner.h file.
12 //===----------------------------------------------------------------------===//
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
28 SaveTemps("save-temps", cl::init(false), cl::desc("Save temporary files"));
33 RemoteClient("remote-client",
34 cl::desc("Remote execution client (rsh/ssh)"));
37 RemoteHost("remote-host",
38 cl::desc("Remote execution (rsh/ssh) host"));
41 RemotePort("remote-port",
42 cl::desc("Remote execution (rsh/ssh) port"));
45 RemoteUser("remote-user",
46 cl::desc("Remote execution (rsh/ssh) user id"));
49 RemoteExtra("remote-extra-options",
50 cl::desc("Remote execution (rsh/ssh) extra options"));
53 ToolExecutionError::~ToolExecutionError() throw() { }
55 /// RunProgramWithTimeout - This function provides an alternate interface
56 /// to the sys::Program::ExecuteAndWait interface.
57 /// @see sys:Program::ExecuteAndWait
58 static int RunProgramWithTimeout(const sys::Path &ProgramPath,
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;
70 #if 0 // For debug purposes
73 for (unsigned i = 0; Args[i]; ++i)
74 errs() << " " << Args[i];
80 sys::Program::ExecuteAndWait(ProgramPath, Args, 0, redirects,
81 NumSeconds, MemoryLimit);
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
89 /// @see sys:Program::ExecuteAndWait
90 static int RunProgramRemotelyWithTimeout(const sys::Path &RemoteClientPath,
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;
102 #if 0 // For debug purposes
105 for (unsigned i = 0; Args[i]; ++i)
106 errs() << " " << Args[i];
111 // Run the program remotely with the remote client
112 int ReturnCode = sys::Program::ExecuteAndWait(RemoteClientPath, Args,
113 0, redirects, NumSeconds, MemoryLimit);
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)
123 // The error message is in the output file, let's print it out from there.
124 std::ifstream ErrorFile(StdOutFile.c_str());
126 std::copy(std::istreambuf_iterator<char>(ErrorFile),
127 std::istreambuf_iterator<char>(),
128 std::ostreambuf_iterator<char>(OS));
132 throw ToolExecutionError(OS.str());
138 static void ProcessFailure(sys::Path ProgPath, const char** Args) {
139 std::ostringstream OS;
140 OS << "\nError running tool:\n ";
141 for (const char **Arg = Args; *Arg; ++Arg)
145 // Rerun the compiler, capturing any error messages to print them.
146 sys::Path ErrorFilename("bugpoint.program_error_messages");
148 if (ErrorFilename.makeUnique(true, &ErrMsg)) {
149 errs() << "Error making unique filename: " << ErrMsg << "\n";
152 RunProgramWithTimeout(ProgPath, Args, sys::Path(""), ErrorFilename,
153 ErrorFilename); // FIXME: check return code ?
155 // Print out the error messages generated by GCC if possible...
156 std::ifstream ErrorFile(ErrorFilename.c_str());
158 std::copy(std::istreambuf_iterator<char>(ErrorFile),
159 std::istreambuf_iterator<char>(),
160 std::ostreambuf_iterator<char>(OS));
164 ErrorFilename.eraseFromDisk();
165 throw ToolExecutionError(OS.str());
168 //===---------------------------------------------------------------------===//
169 // LLI Implementation of AbstractIntepreter interface
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
176 LLI(const std::string &Path, const std::vector<std::string> *Args)
179 if (Args) { ToolArgs = *Args; }
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);
194 int LLI::ExecuteProgram(const std::string &Bitcode,
195 const std::vector<std::string> &Args,
196 const std::string &InputFile,
197 const std::string &OutputFile,
198 const std::vector<std::string> &GCCArgs,
199 const std::vector<std::string> &SharedLibs,
201 unsigned MemoryLimit) {
202 std::vector<const char*> LLIArgs;
203 LLIArgs.push_back(LLIPath.c_str());
204 LLIArgs.push_back("-force-interpreter=true");
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());
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());
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);
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];
227 return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
228 sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
229 Timeout, MemoryLimit);
232 // LLI create method - Try to find the LLI executable
233 AbstractInterpreter *AbstractInterpreter::createLLI(const char *Argv0,
234 std::string &Message,
235 const std::vector<std::string> *ToolArgs) {
236 std::string LLIPath =
237 FindExecutable("lli", Argv0, (void *)(intptr_t)&createLLI).str();
238 if (!LLIPath.empty()) {
239 Message = "Found lli: " + LLIPath + "\n";
240 return new LLI(LLIPath, ToolArgs);
243 Message = "Cannot find `lli' in executable directory or PATH!\n";
247 //===---------------------------------------------------------------------===//
248 // Custom execution command implementation of AbstractIntepreter interface
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.
254 class CustomExecutor : public AbstractInterpreter {
255 std::string ExecutionCommand;
256 std::vector<std::string> ExecutorArgs;
259 const std::string &ExecutionCmd, std::vector<std::string> ExecArgs) :
260 ExecutionCommand(ExecutionCmd), ExecutorArgs(ExecArgs) {}
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);
274 int CustomExecutor::ExecuteProgram(const std::string &Bitcode,
275 const std::vector<std::string> &Args,
276 const std::string &InputFile,
277 const std::string &OutputFile,
278 const std::vector<std::string> &GCCArgs,
279 const std::vector<std::string> &SharedLibs,
281 unsigned MemoryLimit) {
283 std::vector<const char*> ProgramArgs;
284 ProgramArgs.push_back(ExecutionCommand.c_str());
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);
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());
295 return RunProgramWithTimeout(
296 sys::Path(ExecutionCommand),
297 &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
298 sys::Path(OutputFile), Timeout, MemoryLimit);
301 // Custom execution environment create method, takes the execution command
303 AbstractInterpreter *AbstractInterpreter::createCustom(
304 std::string &Message,
305 const std::string &ExecCommandLine) {
307 std::string Command = "";
308 std::vector<std::string> Args;
309 std::string delimiters = " ";
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").
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);
325 while (std::string::npos != pos || std::string::npos != lastPos) {
326 std::string token = ExecCommandLine.substr(lastPos, pos - lastPos);
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);
337 std::string CmdPath = sys::Program::FindProgramByName(Command).str();
338 if (CmdPath.empty()) {
340 std::string("Cannot find '") + Command +
341 "' in executable directory or PATH!\n";
345 Message = "Found command in: " + CmdPath + "\n";
347 return new CustomExecutor(CmdPath, Args);
350 //===----------------------------------------------------------------------===//
351 // LLC Implementation of AbstractIntepreter interface
353 GCC::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);
358 if (uniqueFile.makeUnique(true, &ErrMsg)) {
359 errs() << "Error making unique filename: " << ErrMsg << "\n";
362 OutputAsmFile = uniqueFile;
363 std::vector<const char *> LLCArgs;
364 LLCArgs.push_back(LLCPath.c_str());
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());
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
374 if (UseIntegratedAssembler)
375 LLCArgs.push_back("-filetype=obj");
377 LLCArgs.push_back (0);
379 outs() << (UseIntegratedAssembler ? "<llc-ia>" : "<llc>");
381 DEBUG(errs() << "\nAbout to run:\t";
382 for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
383 errs() << " " << LLCArgs[i];
386 if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
387 sys::Path(), sys::Path(), sys::Path()))
388 ProcessFailure(sys::Path(LLCPath), &LLCArgs[0]);
390 return UseIntegratedAssembler ? GCC::ObjectFile : GCC::AsmFile;
393 void LLC::compileProgram(const std::string &Bitcode) {
394 sys::Path OutputAsmFile;
395 OutputCode(Bitcode, OutputAsmFile);
396 OutputAsmFile.eraseFromDisk();
399 int 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,
406 unsigned MemoryLimit) {
408 sys::Path OutputAsmFile;
409 GCC::FileType FileKind = OutputCode(Bitcode, OutputAsmFile);
410 FileRemover OutFileRemover(OutputAsmFile, !SaveTemps);
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());
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);
422 /// createLLC - Try to find the LLC executable
424 LLC *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";
436 Message = "Found llc: " + LLCPath + "\n";
437 GCC *gcc = GCC::create(Message, GCCArgs);
439 errs() << Message << "\n";
442 return new LLC(LLCPath, gcc, Args, GCCArgs, UseIntegratedAssembler);
445 //===---------------------------------------------------------------------===//
446 // JIT Implementation of AbstractIntepreter interface
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
453 JIT(const std::string &Path, const std::vector<std::string> *Args)
456 if (Args) { ToolArgs = *Args; }
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>(),
468 unsigned MemoryLimit =0);
472 int 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,
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");
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());
489 for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
490 JITArgs.push_back("-load");
491 JITArgs.push_back(SharedLibs[i].c_str());
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);
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];
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);
511 /// createJIT - Try to find the LLI executable
513 AbstractInterpreter *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);
522 Message = "Cannot find `lli' in executable directory or PATH!\n";
526 GCC::FileType CBE::OutputCode(const std::string &Bitcode,
527 sys::Path &OutputCFile) {
528 sys::Path uniqueFile(Bitcode+".cbe.c");
530 if (uniqueFile.makeUnique(true, &ErrMsg)) {
531 errs() << "Error making unique filename: " << ErrMsg << "\n";
534 OutputCFile = uniqueFile;
535 std::vector<const char *> LLCArgs;
536 LLCArgs.push_back (LLCPath.c_str());
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());
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);
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];
555 if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
557 ProcessFailure(LLCPath, &LLCArgs[0]);
561 void CBE::compileProgram(const std::string &Bitcode) {
562 sys::Path OutputCFile;
563 OutputCode(Bitcode, OutputCFile);
564 OutputCFile.eraseFromDisk();
567 int 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,
574 unsigned MemoryLimit) {
575 sys::Path OutputCFile;
576 OutputCode(Bitcode, OutputCFile);
578 FileRemover CFileRemove(OutputCFile, !SaveTemps);
580 std::vector<std::string> GCCArgs(ArgsForGCC);
581 GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
583 return gcc->ExecuteProgram(OutputCFile.str(), Args, GCC::CFile,
584 InputFile, OutputFile, GCCArgs,
585 Timeout, MemoryLimit);
588 /// createCBE - Try to find the 'llc' executable
590 CBE *AbstractInterpreter::createCBE(const char *Argv0,
591 std::string &Message,
592 const std::vector<std::string> *Args,
593 const std::vector<std::string> *GCCArgs) {
595 FindExecutable("llc", Argv0, (void *)(intptr_t)&createCBE);
596 if (LLCPath.isEmpty()) {
598 "Cannot find `llc' in executable directory or PATH!\n";
602 Message = "Found llc: " + LLCPath.str() + "\n";
603 GCC *gcc = GCC::create(Message, GCCArgs);
605 errs() << Message << "\n";
608 return new CBE(LLCPath, gcc, Args);
611 //===---------------------------------------------------------------------===//
615 static 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) {
619 if (!S.equals_lower("-arch")) {
621 if (I != E && !S.substr(0, strlen("arm")).equals_lower("arm"))
629 int GCC::ExecuteProgram(const std::string &ProgramFile,
630 const std::vector<std::string> &Args,
632 const std::string &InputFile,
633 const std::string &OutputFile,
634 const std::vector<std::string> &ArgsForGCC,
636 unsigned MemoryLimit) {
637 std::vector<const char*> GCCArgs;
639 GCCArgs.push_back(GCCPath.c_str());
641 if (TargetTriple.getArch() == Triple::x86)
642 GCCArgs.push_back("-m32");
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());
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");
655 GCCArgs.push_back("assembler");
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
660 if ((TargetTriple.getOS() == Triple::Darwin) &&
661 !IsARMArchitecture(ArgsForGCC))
662 GCCArgs.push_back("-force_cpusubtype_ALL");
666 GCCArgs.push_back(ProgramFile.c_str()); // Specify the input filename.
668 GCCArgs.push_back("-x");
669 GCCArgs.push_back("none");
670 GCCArgs.push_back("-o");
671 sys::Path OutputBinary (ProgramFile+".gcc.exe");
673 if (OutputBinary.makeUnique(true, &ErrMsg)) {
674 errs() << "Error making unique filename: " << ErrMsg << "\n";
677 GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
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());
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
691 if (TargetTriple.getArch() == Triple::sparc)
692 GCCArgs.push_back("-mcpu=v9");
693 GCCArgs.push_back(0); // NULL terminator
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];
701 if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
703 ProcessFailure(GCCPath, &GCCArgs[0]);
707 std::vector<const char*> ProgramArgs;
709 if (RemoteClientPath.isEmpty())
710 ProgramArgs.push_back(OutputBinary.c_str());
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());
718 if (!RemotePort.empty()) {
719 ProgramArgs.push_back("-p");
720 ProgramArgs.push_back(RemotePort.c_str());
722 if (!RemoteExtra.empty()) {
723 ProgramArgs.push_back(RemoteExtra.c_str());
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 ";
732 Exec += OutputBinary.c_str();
733 ProgramArgs.push_back(Exec.c_str());
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
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];
749 FileRemover OutputBinaryRemover(OutputBinary, !SaveTemps);
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);
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);
764 int 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);
769 if (uniqueFilename.makeUnique(true, &ErrMsg)) {
770 errs() << "Error making unique filename: " << ErrMsg << "\n";
773 OutputFile = uniqueFilename.str();
775 std::vector<const char*> GCCArgs;
777 GCCArgs.push_back(GCCPath.c_str());
779 if (TargetTriple.getArch() == Triple::x86)
780 GCCArgs.push_back("-m32");
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());
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");
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");
807 GCCArgs.push_back("-shared"); // `-shared' for Linux/X86, maybe others
809 if ((TargetTriple.getArch() == Triple::alpha) ||
810 (TargetTriple.getArch() == Triple::x86_64))
811 GCCArgs.push_back("-fPIC"); // Requires shared objs to contain PIC
813 if (TargetTriple.getArch() == Triple::sparc)
814 GCCArgs.push_back("-mcpu=v9");
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.
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
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];
838 if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
840 ProcessFailure(GCCPath, &GCCArgs[0]);
846 /// create - Try to find the `gcc' executable
848 GCC *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";
856 sys::Path RemoteClientPath;
857 if (!RemoteClient.empty())
858 RemoteClientPath = sys::Program::FindProgramByName(RemoteClient);
860 Message = "Found gcc: " + GCCPath.str() + "\n";
861 return new GCC(GCCPath, RemoteClientPath, Args);