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