blob: 1719703b57ca36359076c0c681dc1a2264cb273a [file] [log] [blame]
Chris Lattner7915a1e2003-10-14 21:34:11 +00001//===-- ToolRunner.cpp ----------------------------------------------------===//
Misha Brukmanf976c852005-04-21 22:55:34 +00002//
John Criswellb576c942003-10-20 19:43:21 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattner21c62da2007-12-29 20:44:31 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Misha Brukmanf976c852005-04-21 22:55:34 +00007//
John Criswellb576c942003-10-20 19:43:21 +00008//===----------------------------------------------------------------------===//
Chris Lattner7915a1e2003-10-14 21:34:11 +00009//
10// This file implements the interfaces described in the ToolRunner.h file.
11//
12//===----------------------------------------------------------------------===//
13
Chris Lattner0b1fe842003-10-19 02:27:40 +000014#define DEBUG_TYPE "toolrunner"
Chris Lattnerf1b20d82006-06-06 22:30:59 +000015#include "ToolRunner.h"
Michael J. Spencer1f6efa32010-11-29 18:16:10 +000016#include "llvm/Support/Program.h"
Evan Cheng34e400e2007-05-03 18:36:15 +000017#include "llvm/Support/CommandLine.h"
Reid Spencer551ccae2004-09-01 22:55:40 +000018#include "llvm/Support/Debug.h"
19#include "llvm/Support/FileUtilities.h"
Chris Lattner74382b72009-08-23 22:45:37 +000020#include "llvm/Support/raw_ostream.h"
21#include "llvm/Config/config.h" // for HAVE_LINK_R
Chris Lattner7915a1e2003-10-14 21:34:11 +000022#include <fstream>
Chris Lattner89bf9ea2004-02-18 20:38:00 +000023#include <sstream>
Chris Lattner2cdd21c2003-12-14 21:35:53 +000024using namespace llvm;
Brian Gaeked0fde302003-11-11 22:41:34 +000025
Anton Korobeynikov86c006a2009-08-05 09:32:10 +000026namespace llvm {
27 cl::opt<bool>
28 SaveTemps("save-temps", cl::init(false), cl::desc("Save temporary files"));
29}
30
Evan Cheng34e400e2007-05-03 18:36:15 +000031namespace {
32 cl::opt<std::string>
Evan Cheng70f684f2008-09-09 06:11:26 +000033 RemoteClient("remote-client",
34 cl::desc("Remote execution client (rsh/ssh)"));
Evan Cheng34e400e2007-05-03 18:36:15 +000035
36 cl::opt<std::string>
Evan Cheng70f684f2008-09-09 06:11:26 +000037 RemoteHost("remote-host",
38 cl::desc("Remote execution (rsh/ssh) host"));
39
40 cl::opt<std::string>
David Goodwin80becf12009-07-10 21:39:28 +000041 RemotePort("remote-port",
42 cl::desc("Remote execution (rsh/ssh) port"));
43
44 cl::opt<std::string>
Evan Cheng70f684f2008-09-09 06:11:26 +000045 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"));
Evan Cheng34e400e2007-05-03 18:36:15 +000051}
52
Viktor Kutuzovfc2271f2009-07-18 18:39:24 +000053/// RunProgramWithTimeout - This function provides an alternate interface
54/// to the sys::Program::ExecuteAndWait interface.
Nick Lewycky22ff7482010-04-12 05:08:25 +000055/// @see sys::Program::ExecuteAndWait
Chris Lattner45495c52005-02-13 23:13:47 +000056static int RunProgramWithTimeout(const sys::Path &ProgramPath,
57 const char **Args,
58 const sys::Path &StdInFile,
59 const sys::Path &StdOutFile,
60 const sys::Path &StdErrFile,
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +000061 unsigned NumSeconds = 0,
Dan Gohmane1f2e502010-11-09 01:13:31 +000062 unsigned MemoryLimit = 0,
63 std::string *ErrMsg = 0) {
Chris Lattner45495c52005-02-13 23:13:47 +000064 const sys::Path* redirects[3];
65 redirects[0] = &StdInFile;
66 redirects[1] = &StdOutFile;
67 redirects[2] = &StdErrFile;
Viktor Kutuzovfc2271f2009-07-18 18:39:24 +000068
69#if 0 // For debug purposes
70 {
Dan Gohman65f57c22009-07-15 16:35:29 +000071 errs() << "RUN:";
Chris Lattnerd4223502006-09-15 23:01:10 +000072 for (unsigned i = 0; Args[i]; ++i)
Dan Gohman65f57c22009-07-15 16:35:29 +000073 errs() << " " << Args[i];
74 errs() << "\n";
Chris Lattnerd4223502006-09-15 23:01:10 +000075 }
Viktor Kutuzovfc2271f2009-07-18 18:39:24 +000076#endif
Misha Brukmanf976c852005-04-21 22:55:34 +000077
78 return
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +000079 sys::Program::ExecuteAndWait(ProgramPath, Args, 0, redirects,
Dan Gohmane1f2e502010-11-09 01:13:31 +000080 NumSeconds, MemoryLimit, ErrMsg);
Chris Lattner45495c52005-02-13 23:13:47 +000081}
82
Viktor Kutuzovfc2271f2009-07-18 18:39:24 +000083/// RunProgramRemotelyWithTimeout - This function runs the given program
84/// remotely using the given remote client and the sys::Program::ExecuteAndWait.
85/// Returns the remote program exit code or reports a remote client error if it
86/// fails. Remote client is required to return 255 if it failed or program exit
87/// code otherwise.
Nick Lewycky22ff7482010-04-12 05:08:25 +000088/// @see sys::Program::ExecuteAndWait
Viktor Kutuzovfc2271f2009-07-18 18:39:24 +000089static int RunProgramRemotelyWithTimeout(const sys::Path &RemoteClientPath,
90 const char **Args,
91 const sys::Path &StdInFile,
92 const sys::Path &StdOutFile,
93 const sys::Path &StdErrFile,
94 unsigned NumSeconds = 0,
95 unsigned MemoryLimit = 0) {
96 const sys::Path* redirects[3];
97 redirects[0] = &StdInFile;
98 redirects[1] = &StdOutFile;
99 redirects[2] = &StdErrFile;
Chris Lattner45495c52005-02-13 23:13:47 +0000100
Viktor Kutuzovfc2271f2009-07-18 18:39:24 +0000101#if 0 // For debug purposes
102 {
103 errs() << "RUN:";
104 for (unsigned i = 0; Args[i]; ++i)
105 errs() << " " << Args[i];
106 errs() << "\n";
107 }
108#endif
109
110 // Run the program remotely with the remote client
111 int ReturnCode = sys::Program::ExecuteAndWait(RemoteClientPath, Args,
112 0, redirects, NumSeconds, MemoryLimit);
113
114 // Has the remote client fail?
115 if (255 == ReturnCode) {
116 std::ostringstream OS;
117 OS << "\nError running remote client:\n ";
118 for (const char **Arg = Args; *Arg; ++Arg)
119 OS << " " << *Arg;
120 OS << "\n";
121
122 // The error message is in the output file, let's print it out from there.
123 std::ifstream ErrorFile(StdOutFile.c_str());
124 if (ErrorFile) {
125 std::copy(std::istreambuf_iterator<char>(ErrorFile),
126 std::istreambuf_iterator<char>(),
127 std::ostreambuf_iterator<char>(OS));
128 ErrorFile.close();
129 }
130
Nick Lewycky22ff7482010-04-12 05:08:25 +0000131 errs() << OS;
Viktor Kutuzovfc2271f2009-07-18 18:39:24 +0000132 }
133
134 return ReturnCode;
135}
Chris Lattner45495c52005-02-13 23:13:47 +0000136
Duncan Sands41396302010-05-24 07:49:55 +0000137static std::string ProcessFailure(sys::Path ProgPath, const char** Args,
138 unsigned Timeout = 0,
139 unsigned MemoryLimit = 0) {
Chris Lattner89bf9ea2004-02-18 20:38:00 +0000140 std::ostringstream OS;
Chris Lattnera3de1172004-02-18 20:58:00 +0000141 OS << "\nError running tool:\n ";
Chris Lattner89bf9ea2004-02-18 20:38:00 +0000142 for (const char **Arg = Args; *Arg; ++Arg)
143 OS << " " << *Arg;
144 OS << "\n";
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000145
Chris Lattner89bf9ea2004-02-18 20:38:00 +0000146 // Rerun the compiler, capturing any error messages to print them.
Dan Gohmana971b292009-02-12 20:53:27 +0000147 sys::Path ErrorFilename("bugpoint.program_error_messages");
Reid Spencer51c5a282006-08-23 20:34:57 +0000148 std::string ErrMsg;
149 if (ErrorFilename.makeUnique(true, &ErrMsg)) {
Dan Gohman65f57c22009-07-15 16:35:29 +0000150 errs() << "Error making unique filename: " << ErrMsg << "\n";
Reid Spencer51c5a282006-08-23 20:34:57 +0000151 exit(1);
152 }
Reid Spencerb31baa82004-12-19 18:00:21 +0000153 RunProgramWithTimeout(ProgPath, Args, sys::Path(""), ErrorFilename,
Duncan Sands41396302010-05-24 07:49:55 +0000154 ErrorFilename, Timeout, MemoryLimit);
155 // FIXME: check return code ?
Chris Lattner89bf9ea2004-02-18 20:38:00 +0000156
157 // Print out the error messages generated by GCC if possible...
158 std::ifstream ErrorFile(ErrorFilename.c_str());
159 if (ErrorFile) {
160 std::copy(std::istreambuf_iterator<char>(ErrorFile),
161 std::istreambuf_iterator<char>(),
162 std::ostreambuf_iterator<char>(OS));
163 ErrorFile.close();
164 }
165
Reid Spencera229c5c2005-07-08 03:08:58 +0000166 ErrorFilename.eraseFromDisk();
Nick Lewycky22ff7482010-04-12 05:08:25 +0000167 return OS.str();
Chris Lattner89bf9ea2004-02-18 20:38:00 +0000168}
169
Misha Brukman9558c6a2003-09-29 22:39:25 +0000170//===---------------------------------------------------------------------===//
171// LLI Implementation of AbstractIntepreter interface
172//
Chris Lattner2cdd21c2003-12-14 21:35:53 +0000173namespace {
174 class LLI : public AbstractInterpreter {
175 std::string LLIPath; // The path to the LLI executable
Brian Gaeked11577b2004-05-04 21:09:01 +0000176 std::vector<std::string> ToolArgs; // Args to pass to LLI
Chris Lattner2cdd21c2003-12-14 21:35:53 +0000177 public:
Brian Gaeked11577b2004-05-04 21:09:01 +0000178 LLI(const std::string &Path, const std::vector<std::string> *Args)
179 : LLIPath(Path) {
180 ToolArgs.clear ();
Brian Gaeke48b008d2004-05-04 22:02:41 +0000181 if (Args) { ToolArgs = *Args; }
Brian Gaeked11577b2004-05-04 21:09:01 +0000182 }
Misha Brukmanf976c852005-04-21 22:55:34 +0000183
Gabor Greif8ff70c22007-07-04 21:55:50 +0000184 virtual int ExecuteProgram(const std::string &Bitcode,
Chris Lattner2cdd21c2003-12-14 21:35:53 +0000185 const std::vector<std::string> &Args,
186 const std::string &InputFile,
187 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000188 std::string *Error,
Reid Spencer51ab5c82006-06-06 00:00:42 +0000189 const std::vector<std::string> &GCCArgs,
Misha Brukmanf976c852005-04-21 22:55:34 +0000190 const std::vector<std::string> &SharedLibs =
Chris Lattnere96b2ed2004-07-24 07:49:11 +0000191 std::vector<std::string>(),
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +0000192 unsigned Timeout = 0,
193 unsigned MemoryLimit = 0);
Chris Lattner2cdd21c2003-12-14 21:35:53 +0000194 };
195}
Misha Brukman9558c6a2003-09-29 22:39:25 +0000196
Gabor Greif8ff70c22007-07-04 21:55:50 +0000197int LLI::ExecuteProgram(const std::string &Bitcode,
Chris Lattner7915a1e2003-10-14 21:34:11 +0000198 const std::vector<std::string> &Args,
Misha Brukman9558c6a2003-09-29 22:39:25 +0000199 const std::string &InputFile,
200 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000201 std::string *Error,
Reid Spencer51ab5c82006-06-06 00:00:42 +0000202 const std::vector<std::string> &GCCArgs,
Chris Lattnere96b2ed2004-07-24 07:49:11 +0000203 const std::vector<std::string> &SharedLibs,
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +0000204 unsigned Timeout,
205 unsigned MemoryLimit) {
Misha Brukman9558c6a2003-09-29 22:39:25 +0000206 std::vector<const char*> LLIArgs;
207 LLIArgs.push_back(LLIPath.c_str());
Misha Brukman9558c6a2003-09-29 22:39:25 +0000208 LLIArgs.push_back("-force-interpreter=true");
Brian Gaeked11577b2004-05-04 21:09:01 +0000209
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000210 for (std::vector<std::string>::const_iterator i = SharedLibs.begin(),
211 e = SharedLibs.end(); i != e; ++i) {
Duncan Sands3ea11cf2009-11-17 10:20:22 +0000212 LLIArgs.push_back("-load");
213 LLIArgs.push_back((*i).c_str());
214 }
215
Brian Gaeked11577b2004-05-04 21:09:01 +0000216 // Add any extra LLI args.
217 for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
218 LLIArgs.push_back(ToolArgs[i].c_str());
219
Gabor Greif8ff70c22007-07-04 21:55:50 +0000220 LLIArgs.push_back(Bitcode.c_str());
Misha Brukman9558c6a2003-09-29 22:39:25 +0000221 // Add optional parameters to the running program from Argv
222 for (unsigned i=0, e = Args.size(); i != e; ++i)
223 LLIArgs.push_back(Args[i].c_str());
224 LLIArgs.push_back(0);
225
Dan Gohmana1bdced2009-07-15 17:29:42 +0000226 outs() << "<lli>"; outs().flush();
Dan Gohman65f57c22009-07-15 16:35:29 +0000227 DEBUG(errs() << "\nAbout to run:\t";
Chris Lattner7b2ccff2003-10-19 02:14:58 +0000228 for (unsigned i=0, e = LLIArgs.size()-1; i != e; ++i)
Dan Gohman65f57c22009-07-15 16:35:29 +0000229 errs() << " " << LLIArgs[i];
230 errs() << "\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000231 );
Reid Spencerb31baa82004-12-19 18:00:21 +0000232 return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
Misha Brukmanf976c852005-04-21 22:55:34 +0000233 sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Dan Gohmane1f2e502010-11-09 01:13:31 +0000234 Timeout, MemoryLimit, Error);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000235}
236
237// LLI create method - Try to find the LLI executable
Dan Gohman197f7282009-08-05 20:21:17 +0000238AbstractInterpreter *AbstractInterpreter::createLLI(const char *Argv0,
Brian Gaeked11577b2004-05-04 21:09:01 +0000239 std::string &Message,
240 const std::vector<std::string> *ToolArgs) {
Dan Gohman197f7282009-08-05 20:21:17 +0000241 std::string LLIPath =
Mikhail Glushenkovd66f2b72010-11-03 16:14:16 +0000242 PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t)&createLLI).str();
Misha Brukman9558c6a2003-09-29 22:39:25 +0000243 if (!LLIPath.empty()) {
244 Message = "Found lli: " + LLIPath + "\n";
Brian Gaeked11577b2004-05-04 21:09:01 +0000245 return new LLI(LLIPath, ToolArgs);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000246 }
247
Dan Gohman62a5ff52010-10-29 16:15:23 +0000248 Message = "Cannot find `lli' in executable directory!\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000249 return 0;
250}
251
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000252//===---------------------------------------------------------------------===//
Andrew Trickf73311b2011-02-08 18:20:48 +0000253// Custom compiler command implementation of AbstractIntepreter interface
254//
255// Allows using a custom command for compiling the bitcode, thus allows, for
256// example, to compile a bitcode fragment without linking or executing, then
257// using a custom wrapper script to check for compiler errors.
258namespace {
259 class CustomCompiler : public AbstractInterpreter {
260 std::string CompilerCommand;
261 std::vector<std::string> CompilerArgs;
262 public:
263 CustomCompiler(
264 const std::string &CompilerCmd, std::vector<std::string> CompArgs) :
265 CompilerCommand(CompilerCmd), CompilerArgs(CompArgs) {}
266
267 virtual void compileProgram(const std::string &Bitcode,
268 std::string *Error,
269 unsigned Timeout = 0,
270 unsigned MemoryLimit = 0);
271
272 virtual int ExecuteProgram(const std::string &Bitcode,
273 const std::vector<std::string> &Args,
274 const std::string &InputFile,
275 const std::string &OutputFile,
276 std::string *Error,
277 const std::vector<std::string> &GCCArgs =
278 std::vector<std::string>(),
279 const std::vector<std::string> &SharedLibs =
280 std::vector<std::string>(),
281 unsigned Timeout = 0,
282 unsigned MemoryLimit = 0) {
283 *Error = "Execution not supported with -compile-custom";
284 return -1;
285 }
286 };
287}
288
289void CustomCompiler::compileProgram(const std::string &Bitcode,
290 std::string *Error,
291 unsigned Timeout,
292 unsigned MemoryLimit) {
293
294 std::vector<const char*> ProgramArgs;
295 ProgramArgs.push_back(CompilerCommand.c_str());
296
297 for (std::size_t i = 0; i < CompilerArgs.size(); ++i)
298 ProgramArgs.push_back(CompilerArgs.at(i).c_str());
299 ProgramArgs.push_back(Bitcode.c_str());
300 ProgramArgs.push_back(0);
301
302 // Add optional parameters to the running program from Argv
303 for (unsigned i = 0, e = CompilerArgs.size(); i != e; ++i)
304 ProgramArgs.push_back(CompilerArgs[i].c_str());
305
306 if (RunProgramWithTimeout( sys::Path(CompilerCommand), &ProgramArgs[0],
307 sys::Path(), sys::Path(), sys::Path(),
308 Timeout, MemoryLimit, Error))
309 *Error = ProcessFailure(sys::Path(CompilerCommand), &ProgramArgs[0],
310 Timeout, MemoryLimit);
311}
312
313//===---------------------------------------------------------------------===//
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000314// Custom execution command implementation of AbstractIntepreter interface
315//
316// Allows using a custom command for executing the bitcode, thus allows,
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000317// for example, to invoke a cross compiler for code generation followed by
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000318// a simulator that executes the generated binary.
319namespace {
320 class CustomExecutor : public AbstractInterpreter {
321 std::string ExecutionCommand;
322 std::vector<std::string> ExecutorArgs;
323 public:
324 CustomExecutor(
325 const std::string &ExecutionCmd, std::vector<std::string> ExecArgs) :
326 ExecutionCommand(ExecutionCmd), ExecutorArgs(ExecArgs) {}
327
328 virtual int ExecuteProgram(const std::string &Bitcode,
329 const std::vector<std::string> &Args,
330 const std::string &InputFile,
331 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000332 std::string *Error,
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000333 const std::vector<std::string> &GCCArgs,
334 const std::vector<std::string> &SharedLibs =
Nick Lewycky22ff7482010-04-12 05:08:25 +0000335 std::vector<std::string>(),
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000336 unsigned Timeout = 0,
337 unsigned MemoryLimit = 0);
338 };
339}
340
341int CustomExecutor::ExecuteProgram(const std::string &Bitcode,
342 const std::vector<std::string> &Args,
343 const std::string &InputFile,
344 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000345 std::string *Error,
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000346 const std::vector<std::string> &GCCArgs,
347 const std::vector<std::string> &SharedLibs,
348 unsigned Timeout,
349 unsigned MemoryLimit) {
350
351 std::vector<const char*> ProgramArgs;
352 ProgramArgs.push_back(ExecutionCommand.c_str());
353
354 for (std::size_t i = 0; i < ExecutorArgs.size(); ++i)
355 ProgramArgs.push_back(ExecutorArgs.at(i).c_str());
356 ProgramArgs.push_back(Bitcode.c_str());
357 ProgramArgs.push_back(0);
358
359 // Add optional parameters to the running program from Argv
Nick Lewycky22ff7482010-04-12 05:08:25 +0000360 for (unsigned i = 0, e = Args.size(); i != e; ++i)
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000361 ProgramArgs.push_back(Args[i].c_str());
362
363 return RunProgramWithTimeout(
364 sys::Path(ExecutionCommand),
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000365 &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
Dan Gohmane1f2e502010-11-09 01:13:31 +0000366 sys::Path(OutputFile), Timeout, MemoryLimit, Error);
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000367}
368
Andrew Trickf73311b2011-02-08 18:20:48 +0000369// Tokenize the CommandLine to the command and the args to allow
370// defining a full command line as the command instead of just the
371// executed program. We cannot just pass the whole string after the command
372// as a single argument because then program sees only a single
373// command line argument (with spaces in it: "foo bar" instead
374// of "foo" and "bar").
375//
376// code borrowed from:
377// http://oopweb.com/CPP/Documents/CPPHOWTO/Volume/C++Programming-HOWTO-7.html
378static void lexCommand(std::string &Message, const std::string &CommandLine,
379 std::string &CmdPath, std::vector<std::string> Args) {
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000380
381 std::string Command = "";
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000382 std::string delimiters = " ";
383
Andrew Trickf73311b2011-02-08 18:20:48 +0000384 std::string::size_type lastPos = CommandLine.find_first_not_of(delimiters, 0);
385 std::string::size_type pos = CommandLine.find_first_of(delimiters, lastPos);
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000386
387 while (std::string::npos != pos || std::string::npos != lastPos) {
Andrew Trickf73311b2011-02-08 18:20:48 +0000388 std::string token = CommandLine.substr(lastPos, pos - lastPos);
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000389 if (Command == "")
390 Command = token;
391 else
392 Args.push_back(token);
393 // Skip delimiters. Note the "not_of"
Andrew Trickf73311b2011-02-08 18:20:48 +0000394 lastPos = CommandLine.find_first_not_of(delimiters, pos);
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000395 // Find next "non-delimiter"
Andrew Trickf73311b2011-02-08 18:20:48 +0000396 pos = CommandLine.find_first_of(delimiters, lastPos);
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000397 }
398
Andrew Trickf73311b2011-02-08 18:20:48 +0000399 CmdPath = sys::Program::FindProgramByName(Command).str();
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000400 if (CmdPath.empty()) {
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000401 Message =
402 std::string("Cannot find '") + Command +
Dan Gohman62a5ff52010-10-29 16:15:23 +0000403 "' in PATH!\n";
Andrew Trickf73311b2011-02-08 18:20:48 +0000404 return;
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000405 }
406
407 Message = "Found command in: " + CmdPath + "\n";
Andrew Trickf73311b2011-02-08 18:20:48 +0000408}
409
410// Custom execution environment create method, takes the execution command
411// as arguments
412AbstractInterpreter *AbstractInterpreter::createCustomCompiler(
413 std::string &Message,
414 const std::string &CompileCommandLine) {
415
416 std::string CmdPath;
417 std::vector<std::string> Args;
418 lexCommand(Message, CompileCommandLine, CmdPath, Args);
419 if (CmdPath.empty())
420 return 0;
421
422 return new CustomCompiler(CmdPath, Args);
423}
424
425// Custom execution environment create method, takes the execution command
426// as arguments
427AbstractInterpreter *AbstractInterpreter::createCustomExecutor(
428 std::string &Message,
429 const std::string &ExecCommandLine) {
430
431
432 std::string CmdPath;
433 std::vector<std::string> Args;
434 lexCommand(Message, ExecCommandLine, CmdPath, Args);
435 if (CmdPath.empty())
436 return 0;
Anton Korobeynikov9ef74252008-04-28 20:53:48 +0000437
438 return new CustomExecutor(CmdPath, Args);
439}
440
Misha Brukman9558c6a2003-09-29 22:39:25 +0000441//===----------------------------------------------------------------------===//
442// LLC Implementation of AbstractIntepreter interface
443//
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000444GCC::FileType LLC::OutputCode(const std::string &Bitcode,
Duncan Sands41396302010-05-24 07:49:55 +0000445 sys::Path &OutputAsmFile, std::string &Error,
446 unsigned Timeout, unsigned MemoryLimit) {
Chris Lattner50010422010-03-16 06:41:47 +0000447 const char *Suffix = (UseIntegratedAssembler ? ".llc.o" : ".llc.s");
448 sys::Path uniqueFile(Bitcode + Suffix);
Reid Spencer51c5a282006-08-23 20:34:57 +0000449 std::string ErrMsg;
450 if (uniqueFile.makeUnique(true, &ErrMsg)) {
Dan Gohman65f57c22009-07-15 16:35:29 +0000451 errs() << "Error making unique filename: " << ErrMsg << "\n";
Reid Spencer51c5a282006-08-23 20:34:57 +0000452 exit(1);
453 }
Reid Spencer9ac14182004-12-16 23:01:34 +0000454 OutputAsmFile = uniqueFile;
Brian Gaeked11577b2004-05-04 21:09:01 +0000455 std::vector<const char *> LLCArgs;
Chris Lattner50010422010-03-16 06:41:47 +0000456 LLCArgs.push_back(LLCPath.c_str());
Brian Gaeked11577b2004-05-04 21:09:01 +0000457
458 // Add any extra LLC args.
459 for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
460 LLCArgs.push_back(ToolArgs[i].c_str());
461
Chris Lattner50010422010-03-16 06:41:47 +0000462 LLCArgs.push_back("-o");
463 LLCArgs.push_back(OutputAsmFile.c_str()); // Output to the Asm file
464 LLCArgs.push_back(Bitcode.c_str()); // This is the input bitcode
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000465
Chris Lattner50010422010-03-16 06:41:47 +0000466 if (UseIntegratedAssembler)
467 LLCArgs.push_back("-filetype=obj");
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000468
Brian Gaeked11577b2004-05-04 21:09:01 +0000469 LLCArgs.push_back (0);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000470
Chris Lattner50010422010-03-16 06:41:47 +0000471 outs() << (UseIntegratedAssembler ? "<llc-ia>" : "<llc>");
472 outs().flush();
Dan Gohman65f57c22009-07-15 16:35:29 +0000473 DEBUG(errs() << "\nAbout to run:\t";
Nick Lewycky22ff7482010-04-12 05:08:25 +0000474 for (unsigned i = 0, e = LLCArgs.size()-1; i != e; ++i)
Dan Gohman65f57c22009-07-15 16:35:29 +0000475 errs() << " " << LLCArgs[i];
476 errs() << "\n";
Brian Gaeked11577b2004-05-04 21:09:01 +0000477 );
Misha Brukmanf976c852005-04-21 22:55:34 +0000478 if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
Duncan Sands41396302010-05-24 07:49:55 +0000479 sys::Path(), sys::Path(), sys::Path(),
480 Timeout, MemoryLimit))
481 Error = ProcessFailure(sys::Path(LLCPath), &LLCArgs[0],
482 Timeout, MemoryLimit);
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000483 return UseIntegratedAssembler ? GCC::ObjectFile : GCC::AsmFile;
Misha Brukman9558c6a2003-09-29 22:39:25 +0000484}
485
Duncan Sands41396302010-05-24 07:49:55 +0000486void LLC::compileProgram(const std::string &Bitcode, std::string *Error,
487 unsigned Timeout, unsigned MemoryLimit) {
Reid Spencer9ac14182004-12-16 23:01:34 +0000488 sys::Path OutputAsmFile;
Duncan Sands41396302010-05-24 07:49:55 +0000489 OutputCode(Bitcode, OutputAsmFile, *Error, Timeout, MemoryLimit);
Reid Spencera229c5c2005-07-08 03:08:58 +0000490 OutputAsmFile.eraseFromDisk();
Chris Lattner9cbbee32004-02-18 23:24:41 +0000491}
492
Gabor Greif8ff70c22007-07-04 21:55:50 +0000493int LLC::ExecuteProgram(const std::string &Bitcode,
Chris Lattner7915a1e2003-10-14 21:34:11 +0000494 const std::vector<std::string> &Args,
Misha Brukman9558c6a2003-09-29 22:39:25 +0000495 const std::string &InputFile,
496 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000497 std::string *Error,
Reid Spencer51ab5c82006-06-06 00:00:42 +0000498 const std::vector<std::string> &ArgsForGCC,
Chris Lattnere96b2ed2004-07-24 07:49:11 +0000499 const std::vector<std::string> &SharedLibs,
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +0000500 unsigned Timeout,
501 unsigned MemoryLimit) {
Chris Lattnereeed9832003-10-14 21:52:52 +0000502
Reid Spencer9ac14182004-12-16 23:01:34 +0000503 sys::Path OutputAsmFile;
Duncan Sands41396302010-05-24 07:49:55 +0000504 GCC::FileType FileKind = OutputCode(Bitcode, OutputAsmFile, *Error, Timeout,
505 MemoryLimit);
Michael J. Spencerc9c08fb2011-03-31 13:04:19 +0000506 FileRemover OutFileRemover(OutputAsmFile.str(), !SaveTemps);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000507
Reid Spencer51ab5c82006-06-06 00:00:42 +0000508 std::vector<std::string> GCCArgs(ArgsForGCC);
Bill Wendling38efa382009-03-02 23:13:18 +0000509 GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
Reid Spencer51ab5c82006-06-06 00:00:42 +0000510
Misha Brukman9558c6a2003-09-29 22:39:25 +0000511 // Assuming LLC worked, compile the result with GCC and run it.
Chris Lattner50010422010-03-16 06:41:47 +0000512 return gcc->ExecuteProgram(OutputAsmFile.str(), Args, FileKind,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000513 InputFile, OutputFile, Error, GCCArgs,
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +0000514 Timeout, MemoryLimit);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000515}
516
Chris Lattner7915a1e2003-10-14 21:34:11 +0000517/// createLLC - Try to find the LLC executable
Misha Brukman9558c6a2003-09-29 22:39:25 +0000518///
Dan Gohman197f7282009-08-05 20:21:17 +0000519LLC *AbstractInterpreter::createLLC(const char *Argv0,
Brian Gaeked11577b2004-05-04 21:09:01 +0000520 std::string &Message,
Kalle Raiskilafaa95762010-05-10 07:38:37 +0000521 const std::string &GCCBinary,
Bill Wendling38efa382009-03-02 23:13:18 +0000522 const std::vector<std::string> *Args,
Chris Lattner50010422010-03-16 06:41:47 +0000523 const std::vector<std::string> *GCCArgs,
524 bool UseIntegratedAssembler) {
Dan Gohman197f7282009-08-05 20:21:17 +0000525 std::string LLCPath =
Mikhail Glushenkovd66f2b72010-11-03 16:14:16 +0000526 PrependMainExecutablePath("llc", Argv0, (void *)(intptr_t)&createLLC).str();
Misha Brukman9558c6a2003-09-29 22:39:25 +0000527 if (LLCPath.empty()) {
Dan Gohman62a5ff52010-10-29 16:15:23 +0000528 Message = "Cannot find `llc' in executable directory!\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000529 return 0;
530 }
531
532 Message = "Found llc: " + LLCPath + "\n";
Kalle Raiskilafaa95762010-05-10 07:38:37 +0000533 GCC *gcc = GCC::create(Message, GCCBinary, GCCArgs);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000534 if (!gcc) {
Dan Gohman65f57c22009-07-15 16:35:29 +0000535 errs() << Message << "\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000536 exit(1);
537 }
Kalle Raiskilafaa95762010-05-10 07:38:37 +0000538 return new LLC(LLCPath, gcc, Args, UseIntegratedAssembler);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000539}
540
541//===---------------------------------------------------------------------===//
542// JIT Implementation of AbstractIntepreter interface
543//
Chris Lattner2cdd21c2003-12-14 21:35:53 +0000544namespace {
545 class JIT : public AbstractInterpreter {
546 std::string LLIPath; // The path to the LLI executable
Brian Gaeked11577b2004-05-04 21:09:01 +0000547 std::vector<std::string> ToolArgs; // Args to pass to LLI
Chris Lattner2cdd21c2003-12-14 21:35:53 +0000548 public:
Brian Gaeked11577b2004-05-04 21:09:01 +0000549 JIT(const std::string &Path, const std::vector<std::string> *Args)
550 : LLIPath(Path) {
551 ToolArgs.clear ();
Brian Gaeke48b008d2004-05-04 22:02:41 +0000552 if (Args) { ToolArgs = *Args; }
Brian Gaeked11577b2004-05-04 21:09:01 +0000553 }
Misha Brukmanf976c852005-04-21 22:55:34 +0000554
Gabor Greif8ff70c22007-07-04 21:55:50 +0000555 virtual int ExecuteProgram(const std::string &Bitcode,
Chris Lattner2cdd21c2003-12-14 21:35:53 +0000556 const std::vector<std::string> &Args,
557 const std::string &InputFile,
558 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000559 std::string *Error,
Reid Spencer51ab5c82006-06-06 00:00:42 +0000560 const std::vector<std::string> &GCCArgs =
561 std::vector<std::string>(),
Misha Brukmanf976c852005-04-21 22:55:34 +0000562 const std::vector<std::string> &SharedLibs =
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000563 std::vector<std::string>(),
Nick Lewycky22ff7482010-04-12 05:08:25 +0000564 unsigned Timeout = 0,
565 unsigned MemoryLimit = 0);
Chris Lattner2cdd21c2003-12-14 21:35:53 +0000566 };
567}
Misha Brukman9558c6a2003-09-29 22:39:25 +0000568
Gabor Greif8ff70c22007-07-04 21:55:50 +0000569int JIT::ExecuteProgram(const std::string &Bitcode,
Chris Lattner7915a1e2003-10-14 21:34:11 +0000570 const std::vector<std::string> &Args,
Misha Brukman9558c6a2003-09-29 22:39:25 +0000571 const std::string &InputFile,
572 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000573 std::string *Error,
Reid Spencer51ab5c82006-06-06 00:00:42 +0000574 const std::vector<std::string> &GCCArgs,
Chris Lattnere96b2ed2004-07-24 07:49:11 +0000575 const std::vector<std::string> &SharedLibs,
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +0000576 unsigned Timeout,
577 unsigned MemoryLimit) {
Misha Brukman9558c6a2003-09-29 22:39:25 +0000578 // Construct a vector of parameters, incorporating those from the command-line
579 std::vector<const char*> JITArgs;
580 JITArgs.push_back(LLIPath.c_str());
Misha Brukman9558c6a2003-09-29 22:39:25 +0000581 JITArgs.push_back("-force-interpreter=false");
Chris Lattnereeed9832003-10-14 21:52:52 +0000582
Brian Gaeked11577b2004-05-04 21:09:01 +0000583 // Add any extra LLI args.
584 for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
585 JITArgs.push_back(ToolArgs[i].c_str());
586
Chris Lattnereeed9832003-10-14 21:52:52 +0000587 for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
Misha Brukman9558c6a2003-09-29 22:39:25 +0000588 JITArgs.push_back("-load");
Chris Lattnereeed9832003-10-14 21:52:52 +0000589 JITArgs.push_back(SharedLibs[i].c_str());
Misha Brukman9558c6a2003-09-29 22:39:25 +0000590 }
Gabor Greif8ff70c22007-07-04 21:55:50 +0000591 JITArgs.push_back(Bitcode.c_str());
Misha Brukman9558c6a2003-09-29 22:39:25 +0000592 // Add optional parameters to the running program from Argv
593 for (unsigned i=0, e = Args.size(); i != e; ++i)
594 JITArgs.push_back(Args[i].c_str());
595 JITArgs.push_back(0);
596
Dan Gohmana1bdced2009-07-15 17:29:42 +0000597 outs() << "<jit>"; outs().flush();
Dan Gohman65f57c22009-07-15 16:35:29 +0000598 DEBUG(errs() << "\nAbout to run:\t";
Chris Lattner7b2ccff2003-10-19 02:14:58 +0000599 for (unsigned i=0, e = JITArgs.size()-1; i != e; ++i)
Dan Gohman65f57c22009-07-15 16:35:29 +0000600 errs() << " " << JITArgs[i];
601 errs() << "\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000602 );
Dan Gohman65f57c22009-07-15 16:35:29 +0000603 DEBUG(errs() << "\nSending output to " << OutputFile << "\n");
Reid Spencerb31baa82004-12-19 18:00:21 +0000604 return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
Misha Brukmanf976c852005-04-21 22:55:34 +0000605 sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Dan Gohmane1f2e502010-11-09 01:13:31 +0000606 Timeout, MemoryLimit, Error);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000607}
608
Chris Lattner7915a1e2003-10-14 21:34:11 +0000609/// createJIT - Try to find the LLI executable
Misha Brukman9558c6a2003-09-29 22:39:25 +0000610///
Dan Gohman197f7282009-08-05 20:21:17 +0000611AbstractInterpreter *AbstractInterpreter::createJIT(const char *Argv0,
Brian Gaeked11577b2004-05-04 21:09:01 +0000612 std::string &Message, const std::vector<std::string> *Args) {
Dan Gohman197f7282009-08-05 20:21:17 +0000613 std::string LLIPath =
Mikhail Glushenkovd66f2b72010-11-03 16:14:16 +0000614 PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t)&createJIT).str();
Misha Brukman9558c6a2003-09-29 22:39:25 +0000615 if (!LLIPath.empty()) {
616 Message = "Found lli: " + LLIPath + "\n";
Brian Gaeked11577b2004-05-04 21:09:01 +0000617 return new JIT(LLIPath, Args);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000618 }
619
Dan Gohman62a5ff52010-10-29 16:15:23 +0000620 Message = "Cannot find `lli' in executable directory!\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000621 return 0;
622}
623
Gabor Greif8ff70c22007-07-04 21:55:50 +0000624GCC::FileType CBE::OutputCode(const std::string &Bitcode,
Duncan Sands41396302010-05-24 07:49:55 +0000625 sys::Path &OutputCFile, std::string &Error,
626 unsigned Timeout, unsigned MemoryLimit) {
Gabor Greif8ff70c22007-07-04 21:55:50 +0000627 sys::Path uniqueFile(Bitcode+".cbe.c");
Reid Spencer51c5a282006-08-23 20:34:57 +0000628 std::string ErrMsg;
629 if (uniqueFile.makeUnique(true, &ErrMsg)) {
Dan Gohman65f57c22009-07-15 16:35:29 +0000630 errs() << "Error making unique filename: " << ErrMsg << "\n";
Reid Spencer51c5a282006-08-23 20:34:57 +0000631 exit(1);
632 }
Reid Spencer9ac14182004-12-16 23:01:34 +0000633 OutputCFile = uniqueFile;
Brian Gaeked11577b2004-05-04 21:09:01 +0000634 std::vector<const char *> LLCArgs;
Nick Lewycky22ff7482010-04-12 05:08:25 +0000635 LLCArgs.push_back(LLCPath.c_str());
Brian Gaeked11577b2004-05-04 21:09:01 +0000636
637 // Add any extra LLC args.
638 for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
639 LLCArgs.push_back(ToolArgs[i].c_str());
640
Nick Lewycky22ff7482010-04-12 05:08:25 +0000641 LLCArgs.push_back("-o");
642 LLCArgs.push_back(OutputCFile.c_str()); // Output to the C file
643 LLCArgs.push_back("-march=c"); // Output C language
Nick Lewycky22ff7482010-04-12 05:08:25 +0000644 LLCArgs.push_back(Bitcode.c_str()); // This is the input bitcode
645 LLCArgs.push_back(0);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000646
Dan Gohmana1bdced2009-07-15 17:29:42 +0000647 outs() << "<cbe>"; outs().flush();
Dan Gohman65f57c22009-07-15 16:35:29 +0000648 DEBUG(errs() << "\nAbout to run:\t";
Nick Lewycky22ff7482010-04-12 05:08:25 +0000649 for (unsigned i = 0, e = LLCArgs.size()-1; i != e; ++i)
Dan Gohman65f57c22009-07-15 16:35:29 +0000650 errs() << " " << LLCArgs[i];
651 errs() << "\n";
Brian Gaeked11577b2004-05-04 21:09:01 +0000652 );
Misha Brukmanf976c852005-04-21 22:55:34 +0000653 if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
Duncan Sands41396302010-05-24 07:49:55 +0000654 sys::Path(), Timeout, MemoryLimit))
655 Error = ProcessFailure(LLCPath, &LLCArgs[0], Timeout, MemoryLimit);
Chris Lattnerc600f3c2006-09-15 21:29:15 +0000656 return GCC::CFile;
Misha Brukman9558c6a2003-09-29 22:39:25 +0000657}
658
Duncan Sands41396302010-05-24 07:49:55 +0000659void CBE::compileProgram(const std::string &Bitcode, std::string *Error,
660 unsigned Timeout, unsigned MemoryLimit) {
Reid Spencer9ac14182004-12-16 23:01:34 +0000661 sys::Path OutputCFile;
Duncan Sands41396302010-05-24 07:49:55 +0000662 OutputCode(Bitcode, OutputCFile, *Error, Timeout, MemoryLimit);
Reid Spencera229c5c2005-07-08 03:08:58 +0000663 OutputCFile.eraseFromDisk();
Chris Lattner9cbbee32004-02-18 23:24:41 +0000664}
665
Gabor Greif8ff70c22007-07-04 21:55:50 +0000666int CBE::ExecuteProgram(const std::string &Bitcode,
Chris Lattner7915a1e2003-10-14 21:34:11 +0000667 const std::vector<std::string> &Args,
Misha Brukman9558c6a2003-09-29 22:39:25 +0000668 const std::string &InputFile,
669 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000670 std::string *Error,
Reid Spencer51ab5c82006-06-06 00:00:42 +0000671 const std::vector<std::string> &ArgsForGCC,
Chris Lattnere96b2ed2004-07-24 07:49:11 +0000672 const std::vector<std::string> &SharedLibs,
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +0000673 unsigned Timeout,
674 unsigned MemoryLimit) {
Reid Spencer9ac14182004-12-16 23:01:34 +0000675 sys::Path OutputCFile;
Duncan Sands41396302010-05-24 07:49:55 +0000676 OutputCode(Bitcode, OutputCFile, *Error, Timeout, MemoryLimit);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000677
Michael J. Spencerc9c08fb2011-03-31 13:04:19 +0000678 FileRemover CFileRemove(OutputCFile.str(), !SaveTemps);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000679
Reid Spencer51ab5c82006-06-06 00:00:42 +0000680 std::vector<std::string> GCCArgs(ArgsForGCC);
Bill Wendling38efa382009-03-02 23:13:18 +0000681 GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end());
682
Chris Lattner74382b72009-08-23 22:45:37 +0000683 return gcc->ExecuteProgram(OutputCFile.str(), Args, GCC::CFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000684 InputFile, OutputFile, Error, GCCArgs,
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +0000685 Timeout, MemoryLimit);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000686}
687
Chris Lattner9915cd92004-02-17 06:40:06 +0000688/// createCBE - Try to find the 'llc' executable
Misha Brukman9558c6a2003-09-29 22:39:25 +0000689///
Dan Gohman197f7282009-08-05 20:21:17 +0000690CBE *AbstractInterpreter::createCBE(const char *Argv0,
Brian Gaeked11577b2004-05-04 21:09:01 +0000691 std::string &Message,
Mikhail Glushenkovd66f2b72010-11-03 16:14:16 +0000692 const std::string &GCCBinary,
Bill Wendling38efa382009-03-02 23:13:18 +0000693 const std::vector<std::string> *Args,
694 const std::vector<std::string> *GCCArgs) {
Dan Gohman197f7282009-08-05 20:21:17 +0000695 sys::Path LLCPath =
Mikhail Glushenkovd66f2b72010-11-03 16:14:16 +0000696 PrependMainExecutablePath("llc", Argv0, (void *)(intptr_t)&createCBE);
Reid Spencerb31baa82004-12-19 18:00:21 +0000697 if (LLCPath.isEmpty()) {
Misha Brukmanf976c852005-04-21 22:55:34 +0000698 Message =
Dan Gohman62a5ff52010-10-29 16:15:23 +0000699 "Cannot find `llc' in executable directory!\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000700 return 0;
701 }
702
Chris Lattner74382b72009-08-23 22:45:37 +0000703 Message = "Found llc: " + LLCPath.str() + "\n";
Kalle Raiskilafaa95762010-05-10 07:38:37 +0000704 GCC *gcc = GCC::create(Message, GCCBinary, GCCArgs);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000705 if (!gcc) {
Dan Gohman65f57c22009-07-15 16:35:29 +0000706 errs() << Message << "\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000707 exit(1);
708 }
Brian Gaeked11577b2004-05-04 21:09:01 +0000709 return new CBE(LLCPath, gcc, Args);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000710}
711
712//===---------------------------------------------------------------------===//
713// GCC abstraction
714//
David Goodwin80becf12009-07-10 21:39:28 +0000715
Jakob Stoklund Olesen887b7032010-07-29 00:52:16 +0000716static bool IsARMArchitecture(std::vector<const char*> Args) {
717 for (std::vector<const char*>::const_iterator
David Goodwin80becf12009-07-10 21:39:28 +0000718 I = Args.begin(), E = Args.end(); I != E; ++I) {
Jakob Stoklund Olesen18e05b42010-05-13 17:58:15 +0000719 if (StringRef(*I).equals_lower("-arch")) {
David Goodwin80becf12009-07-10 21:39:28 +0000720 ++I;
Jakob Stoklund Olesen18e05b42010-05-13 17:58:15 +0000721 if (I != E && StringRef(*I).substr(0, strlen("arm")).equals_lower("arm"))
David Goodwin80becf12009-07-10 21:39:28 +0000722 return true;
David Goodwin80becf12009-07-10 21:39:28 +0000723 }
724 }
725
726 return false;
727}
728
Misha Brukman9558c6a2003-09-29 22:39:25 +0000729int GCC::ExecuteProgram(const std::string &ProgramFile,
Chris Lattner7915a1e2003-10-14 21:34:11 +0000730 const std::vector<std::string> &Args,
Misha Brukman9558c6a2003-09-29 22:39:25 +0000731 FileType fileType,
732 const std::string &InputFile,
733 const std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000734 std::string *Error,
Reid Spencer51ab5c82006-06-06 00:00:42 +0000735 const std::vector<std::string> &ArgsForGCC,
Anton Korobeynikov9ba8a762007-02-16 19:11:07 +0000736 unsigned Timeout,
737 unsigned MemoryLimit) {
Misha Brukman9558c6a2003-09-29 22:39:25 +0000738 std::vector<const char*> GCCArgs;
739
740 GCCArgs.push_back(GCCPath.c_str());
Chris Lattnereeed9832003-10-14 21:52:52 +0000741
Chris Lattner50010422010-03-16 06:41:47 +0000742 if (TargetTriple.getArch() == Triple::x86)
743 GCCArgs.push_back("-m32");
744
Bill Wendling38efa382009-03-02 23:13:18 +0000745 for (std::vector<std::string>::const_iterator
746 I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
747 GCCArgs.push_back(I->c_str());
748
Chris Lattnereeed9832003-10-14 21:52:52 +0000749 // Specify -x explicitly in case the extension is wonky
Chris Lattner50010422010-03-16 06:41:47 +0000750 if (fileType != ObjectFile) {
751 GCCArgs.push_back("-x");
752 if (fileType == CFile) {
753 GCCArgs.push_back("c");
754 GCCArgs.push_back("-fno-strict-aliasing");
755 } else {
756 GCCArgs.push_back("assembler");
Daniel Dunbarca740962009-08-18 03:35:57 +0000757
Chris Lattner50010422010-03-16 06:41:47 +0000758 // For ARM architectures we don't want this flag. bugpoint isn't
759 // explicitly told what architecture it is working on, so we get
760 // it from gcc flags
761 if ((TargetTriple.getOS() == Triple::Darwin) &&
Jakob Stoklund Olesen887b7032010-07-29 00:52:16 +0000762 !IsARMArchitecture(GCCArgs))
Chris Lattner50010422010-03-16 06:41:47 +0000763 GCCArgs.push_back("-force_cpusubtype_ALL");
764 }
Misha Brukman9558c6a2003-09-29 22:39:25 +0000765 }
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000766
Chris Lattner50010422010-03-16 06:41:47 +0000767 GCCArgs.push_back(ProgramFile.c_str()); // Specify the input filename.
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000768
Chris Lattner629e4872006-06-09 21:31:53 +0000769 GCCArgs.push_back("-x");
770 GCCArgs.push_back("none");
Misha Brukman9558c6a2003-09-29 22:39:25 +0000771 GCCArgs.push_back("-o");
Reid Spencercda985e2004-12-15 01:51:56 +0000772 sys::Path OutputBinary (ProgramFile+".gcc.exe");
Reid Spencer51c5a282006-08-23 20:34:57 +0000773 std::string ErrMsg;
774 if (OutputBinary.makeUnique(true, &ErrMsg)) {
Dan Gohman65f57c22009-07-15 16:35:29 +0000775 errs() << "Error making unique filename: " << ErrMsg << "\n";
Reid Spencer51c5a282006-08-23 20:34:57 +0000776 exit(1);
777 }
Misha Brukman9558c6a2003-09-29 22:39:25 +0000778 GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
Reid Spencer51ab5c82006-06-06 00:00:42 +0000779
780 // Add any arguments intended for GCC. We locate them here because this is
781 // most likely -L and -l options that need to come before other libraries but
782 // after the source. Other options won't be sensitive to placement on the
783 // command line, so this should be safe.
784 for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
785 GCCArgs.push_back(ArgsForGCC[i].c_str());
786
Misha Brukman9558c6a2003-09-29 22:39:25 +0000787 GCCArgs.push_back("-lm"); // Hard-code the math library...
788 GCCArgs.push_back("-O2"); // Optimize the program a bit...
Brian Gaekec8db76c2003-11-18 06:31:17 +0000789#if defined (HAVE_LINK_R)
Chris Lattner1f0f1622003-10-18 21:54:47 +0000790 GCCArgs.push_back("-Wl,-R."); // Search this dir for .so files
Brian Gaekec8db76c2003-11-18 06:31:17 +0000791#endif
Daniel Dunbarca740962009-08-18 03:35:57 +0000792 if (TargetTriple.getArch() == Triple::sparc)
793 GCCArgs.push_back("-mcpu=v9");
Misha Brukman9558c6a2003-09-29 22:39:25 +0000794 GCCArgs.push_back(0); // NULL terminator
795
Dan Gohmana1bdced2009-07-15 17:29:42 +0000796 outs() << "<gcc>"; outs().flush();
Dan Gohman65f57c22009-07-15 16:35:29 +0000797 DEBUG(errs() << "\nAbout to run:\t";
Nick Lewycky22ff7482010-04-12 05:08:25 +0000798 for (unsigned i = 0, e = GCCArgs.size()-1; i != e; ++i)
Dan Gohman65f57c22009-07-15 16:35:29 +0000799 errs() << " " << GCCArgs[i];
800 errs() << "\n";
Evan Cheng7f7fdcc2007-01-03 07:44:30 +0000801 );
Reid Spencerb31baa82004-12-19 18:00:21 +0000802 if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
803 sys::Path())) {
Nick Lewycky22ff7482010-04-12 05:08:25 +0000804 *Error = ProcessFailure(GCCPath, &GCCArgs[0]);
805 return -1;
Misha Brukman9558c6a2003-09-29 22:39:25 +0000806 }
807
Rafael Espindolab30cdd82010-07-24 23:05:45 +0000808 std::vector<const char*> ProgramArgs;
Rafael Espindola97595eb2010-07-24 23:02:11 +0000809
810 // Declared here so that the destructor only runs after
811 // ProgramArgs is used.
812 std::string Exec;
Chris Lattner45495c52005-02-13 23:13:47 +0000813
Evan Cheng70f684f2008-09-09 06:11:26 +0000814 if (RemoteClientPath.isEmpty())
Evan Cheng34e400e2007-05-03 18:36:15 +0000815 ProgramArgs.push_back(OutputBinary.c_str());
816 else {
Evan Cheng70f684f2008-09-09 06:11:26 +0000817 ProgramArgs.push_back(RemoteClientPath.c_str());
818 ProgramArgs.push_back(RemoteHost.c_str());
Anton Korobeynikov26964b62009-08-05 09:32:53 +0000819 if (!RemoteUser.empty()) {
820 ProgramArgs.push_back("-l");
821 ProgramArgs.push_back(RemoteUser.c_str());
822 }
David Goodwin80becf12009-07-10 21:39:28 +0000823 if (!RemotePort.empty()) {
824 ProgramArgs.push_back("-p");
825 ProgramArgs.push_back(RemotePort.c_str());
826 }
Evan Cheng70f684f2008-09-09 06:11:26 +0000827 if (!RemoteExtra.empty()) {
828 ProgramArgs.push_back(RemoteExtra.c_str());
829 }
Evan Cheng34e400e2007-05-03 18:36:15 +0000830
David Goodwin91cf3612009-07-20 17:15:03 +0000831 // Full path to the binary. We need to cd to the exec directory because
832 // there is a dylib there that the exec expects to find in the CWD
Evan Cheng34e400e2007-05-03 18:36:15 +0000833 char* env_pwd = getenv("PWD");
Rafael Espindola97595eb2010-07-24 23:02:11 +0000834 Exec = "cd ";
Evan Cheng34e400e2007-05-03 18:36:15 +0000835 Exec += env_pwd;
David Goodwin91cf3612009-07-20 17:15:03 +0000836 Exec += "; ./";
Evan Cheng34e400e2007-05-03 18:36:15 +0000837 Exec += OutputBinary.c_str();
838 ProgramArgs.push_back(Exec.c_str());
839 }
840
Misha Brukman9558c6a2003-09-29 22:39:25 +0000841 // Add optional parameters to the running program from Argv
Nick Lewycky22ff7482010-04-12 05:08:25 +0000842 for (unsigned i = 0, e = Args.size(); i != e; ++i)
Misha Brukman9558c6a2003-09-29 22:39:25 +0000843 ProgramArgs.push_back(Args[i].c_str());
844 ProgramArgs.push_back(0); // NULL terminator
845
846 // Now that we have a binary, run it!
Dan Gohmana1bdced2009-07-15 17:29:42 +0000847 outs() << "<program>"; outs().flush();
Dan Gohman65f57c22009-07-15 16:35:29 +0000848 DEBUG(errs() << "\nAbout to run:\t";
Nick Lewycky22ff7482010-04-12 05:08:25 +0000849 for (unsigned i = 0, e = ProgramArgs.size()-1; i != e; ++i)
Dan Gohman65f57c22009-07-15 16:35:29 +0000850 errs() << " " << ProgramArgs[i];
851 errs() << "\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000852 );
Chris Lattner8c56be52004-02-18 20:21:57 +0000853
Michael J. Spencerc9c08fb2011-03-31 13:04:19 +0000854 FileRemover OutputBinaryRemover(OutputBinary.str(), !SaveTemps);
Evan Cheng34e400e2007-05-03 18:36:15 +0000855
Viktor Kutuzov699220b2009-07-14 19:10:55 +0000856 if (RemoteClientPath.isEmpty()) {
Nick Lewycky22ff7482010-04-12 05:08:25 +0000857 DEBUG(errs() << "<run locally>");
Evan Cheng34e400e2007-05-03 18:36:15 +0000858 return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
859 sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
Dan Gohmane1f2e502010-11-09 01:13:31 +0000860 Timeout, MemoryLimit, Error);
Viktor Kutuzov699220b2009-07-14 19:10:55 +0000861 } else {
Dan Gohmana1bdced2009-07-15 17:29:42 +0000862 outs() << "<run remotely>"; outs().flush();
Viktor Kutuzovfc2271f2009-07-18 18:39:24 +0000863 return RunProgramRemotelyWithTimeout(sys::Path(RemoteClientPath),
Viktor Kutuzov699220b2009-07-14 19:10:55 +0000864 &ProgramArgs[0], sys::Path(InputFile), sys::Path(OutputFile),
865 sys::Path(OutputFile), Timeout, MemoryLimit);
Viktor Kutuzov699220b2009-07-14 19:10:55 +0000866 }
Misha Brukman9558c6a2003-09-29 22:39:25 +0000867}
868
Chris Lattner1798e4a2003-10-14 21:07:25 +0000869int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType,
Chris Lattner130e2a32006-06-27 20:35:36 +0000870 std::string &OutputFile,
Nick Lewycky22ff7482010-04-12 05:08:25 +0000871 const std::vector<std::string> &ArgsForGCC,
872 std::string &Error) {
Reid Spencercda985e2004-12-15 01:51:56 +0000873 sys::Path uniqueFilename(InputFile+LTDL_SHLIB_EXT);
Reid Spencer51c5a282006-08-23 20:34:57 +0000874 std::string ErrMsg;
875 if (uniqueFilename.makeUnique(true, &ErrMsg)) {
Dan Gohman65f57c22009-07-15 16:35:29 +0000876 errs() << "Error making unique filename: " << ErrMsg << "\n";
Reid Spencer51c5a282006-08-23 20:34:57 +0000877 exit(1);
878 }
Chris Lattner74382b72009-08-23 22:45:37 +0000879 OutputFile = uniqueFilename.str();
Reid Spencercda985e2004-12-15 01:51:56 +0000880
Chris Lattner130e2a32006-06-27 20:35:36 +0000881 std::vector<const char*> GCCArgs;
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000882
Chris Lattner130e2a32006-06-27 20:35:36 +0000883 GCCArgs.push_back(GCCPath.c_str());
Evan Chengfd829952009-03-12 00:53:34 +0000884
Chris Lattner50010422010-03-16 06:41:47 +0000885 if (TargetTriple.getArch() == Triple::x86)
886 GCCArgs.push_back("-m32");
887
Evan Chengfd829952009-03-12 00:53:34 +0000888 for (std::vector<std::string>::const_iterator
889 I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I)
890 GCCArgs.push_back(I->c_str());
891
Misha Brukman9558c6a2003-09-29 22:39:25 +0000892 // Compile the C/asm file into a shared object
Chris Lattner50010422010-03-16 06:41:47 +0000893 if (fileType != ObjectFile) {
894 GCCArgs.push_back("-x");
895 GCCArgs.push_back(fileType == AsmFile ? "assembler" : "c");
896 }
Chris Lattner130e2a32006-06-27 20:35:36 +0000897 GCCArgs.push_back("-fno-strict-aliasing");
898 GCCArgs.push_back(InputFile.c_str()); // Specify the input filename.
Lauro Ramos Venancio497391a2007-06-06 23:10:56 +0000899 GCCArgs.push_back("-x");
900 GCCArgs.push_back("none");
Daniel Dunbarca740962009-08-18 03:35:57 +0000901 if (TargetTriple.getArch() == Triple::sparc)
902 GCCArgs.push_back("-G"); // Compile a shared library, `-G' for Sparc
903 else if (TargetTriple.getOS() == Triple::Darwin) {
904 // link all source files into a single module in data segment, rather than
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000905 // generating blocks. dynamic_lookup requires that you set
Daniel Dunbarca740962009-08-18 03:35:57 +0000906 // MACOSX_DEPLOYMENT_TARGET=10.3 in your env. FIXME: it would be better for
907 // bugpoint to just pass that in the environment of GCC.
908 GCCArgs.push_back("-single_module");
909 GCCArgs.push_back("-dynamiclib"); // `-dynamiclib' for MacOS X/PowerPC
910 GCCArgs.push_back("-undefined");
911 GCCArgs.push_back("dynamic_lookup");
912 } else
913 GCCArgs.push_back("-shared"); // `-shared' for Linux/X86, maybe others
Chris Lattner1c81f132005-03-09 03:31:02 +0000914
Daniel Dunbarca740962009-08-18 03:35:57 +0000915 if ((TargetTriple.getArch() == Triple::alpha) ||
916 (TargetTriple.getArch() == Triple::x86_64))
917 GCCArgs.push_back("-fPIC"); // Requires shared objs to contain PIC
918
919 if (TargetTriple.getArch() == Triple::sparc)
920 GCCArgs.push_back("-mcpu=v9");
921
Chris Lattner130e2a32006-06-27 20:35:36 +0000922 GCCArgs.push_back("-o");
923 GCCArgs.push_back(OutputFile.c_str()); // Output to the right filename.
924 GCCArgs.push_back("-O2"); // Optimize the program a bit.
925
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000926
927
Chris Lattner130e2a32006-06-27 20:35:36 +0000928 // Add any arguments intended for GCC. We locate them here because this is
929 // most likely -L and -l options that need to come before other libraries but
930 // after the source. Other options won't be sensitive to placement on the
931 // command line, so this should be safe.
932 for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
933 GCCArgs.push_back(ArgsForGCC[i].c_str());
934 GCCArgs.push_back(0); // NULL terminator
935
Mikhail Glushenkov544fba12010-11-03 16:14:07 +0000936
Misha Brukmanf976c852005-04-21 22:55:34 +0000937
Dan Gohmana1bdced2009-07-15 17:29:42 +0000938 outs() << "<gcc>"; outs().flush();
Dan Gohman65f57c22009-07-15 16:35:29 +0000939 DEBUG(errs() << "\nAbout to run:\t";
Nick Lewycky22ff7482010-04-12 05:08:25 +0000940 for (unsigned i = 0, e = GCCArgs.size()-1; i != e; ++i)
Dan Gohman65f57c22009-07-15 16:35:29 +0000941 errs() << " " << GCCArgs[i];
942 errs() << "\n";
Evan Cheng7f7fdcc2007-01-03 07:44:30 +0000943 );
Chris Lattner130e2a32006-06-27 20:35:36 +0000944 if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
Reid Spencerb31baa82004-12-19 18:00:21 +0000945 sys::Path())) {
Nick Lewycky22ff7482010-04-12 05:08:25 +0000946 Error = ProcessFailure(GCCPath, &GCCArgs[0]);
Chris Lattner1798e4a2003-10-14 21:07:25 +0000947 return 1;
Misha Brukman9558c6a2003-09-29 22:39:25 +0000948 }
949 return 0;
950}
951
Chris Lattner7915a1e2003-10-14 21:34:11 +0000952/// create - Try to find the `gcc' executable
Misha Brukman9558c6a2003-09-29 22:39:25 +0000953///
Dan Gohman197f7282009-08-05 20:21:17 +0000954GCC *GCC::create(std::string &Message,
Kalle Raiskilafaa95762010-05-10 07:38:37 +0000955 const std::string &GCCBinary,
Bill Wendling38efa382009-03-02 23:13:18 +0000956 const std::vector<std::string> *Args) {
Kalle Raiskilafaa95762010-05-10 07:38:37 +0000957 sys::Path GCCPath = sys::Program::FindProgramByName(GCCBinary);
Reid Spencerb31baa82004-12-19 18:00:21 +0000958 if (GCCPath.isEmpty()) {
Dan Gohman62a5ff52010-10-29 16:15:23 +0000959 Message = "Cannot find `"+ GCCBinary +"' in PATH!\n";
Misha Brukman9558c6a2003-09-29 22:39:25 +0000960 return 0;
961 }
962
Evan Cheng70f684f2008-09-09 06:11:26 +0000963 sys::Path RemoteClientPath;
964 if (!RemoteClient.empty())
Dan Gohman197f7282009-08-05 20:21:17 +0000965 RemoteClientPath = sys::Program::FindProgramByName(RemoteClient);
Evan Cheng34e400e2007-05-03 18:36:15 +0000966
Chris Lattner74382b72009-08-23 22:45:37 +0000967 Message = "Found gcc: " + GCCPath.str() + "\n";
Bill Wendling38efa382009-03-02 23:13:18 +0000968 return new GCC(GCCPath, RemoteClientPath, Args);
Misha Brukman9558c6a2003-09-29 22:39:25 +0000969}