diff options
Diffstat (limited to 'llvm/tools/bugpoint/ToolRunner.cpp')
| -rw-r--r-- | llvm/tools/bugpoint/ToolRunner.cpp | 503 |
1 files changed, 231 insertions, 272 deletions
diff --git a/llvm/tools/bugpoint/ToolRunner.cpp b/llvm/tools/bugpoint/ToolRunner.cpp index 4af4b10c4d7..98bc4d846b6 100644 --- a/llvm/tools/bugpoint/ToolRunner.cpp +++ b/llvm/tools/bugpoint/ToolRunner.cpp @@ -12,7 +12,7 @@ //===----------------------------------------------------------------------===// #include "ToolRunner.h" -#include "llvm/Config/config.h" // for HAVE_LINK_R +#include "llvm/Config/config.h" // for HAVE_LINK_R #include "llvm/Support/CommandLine.h" #include "llvm/Support/Debug.h" #include "llvm/Support/FileSystem.h" @@ -27,46 +27,40 @@ using namespace llvm; #define DEBUG_TYPE "toolrunner" namespace llvm { - cl::opt<bool> - SaveTemps("save-temps", cl::init(false), cl::desc("Save temporary files")); +cl::opt<bool> SaveTemps("save-temps", cl::init(false), + cl::desc("Save temporary files")); } namespace { - cl::opt<std::string> - RemoteClient("remote-client", - cl::desc("Remote execution client (rsh/ssh)")); +cl::opt<std::string> + RemoteClient("remote-client", + cl::desc("Remote execution client (rsh/ssh)")); - cl::opt<std::string> - RemoteHost("remote-host", - cl::desc("Remote execution (rsh/ssh) host")); +cl::opt<std::string> RemoteHost("remote-host", + cl::desc("Remote execution (rsh/ssh) host")); - cl::opt<std::string> - RemotePort("remote-port", - cl::desc("Remote execution (rsh/ssh) port")); +cl::opt<std::string> RemotePort("remote-port", + cl::desc("Remote execution (rsh/ssh) port")); - cl::opt<std::string> - RemoteUser("remote-user", - cl::desc("Remote execution (rsh/ssh) user id")); +cl::opt<std::string> RemoteUser("remote-user", + cl::desc("Remote execution (rsh/ssh) user id")); - cl::opt<std::string> - RemoteExtra("remote-extra-options", - cl::desc("Remote execution (rsh/ssh) extra options")); +cl::opt<std::string> + RemoteExtra("remote-extra-options", + cl::desc("Remote execution (rsh/ssh) extra options")); } /// RunProgramWithTimeout - This function provides an alternate interface /// to the sys::Program::ExecuteAndWait interface. /// @see sys::Program::ExecuteAndWait -static int RunProgramWithTimeout(StringRef ProgramPath, - const char **Args, - StringRef StdInFile, - StringRef StdOutFile, - StringRef StdErrFile, - unsigned NumSeconds = 0, +static int RunProgramWithTimeout(StringRef ProgramPath, const char **Args, + StringRef StdInFile, StringRef StdOutFile, + StringRef StdErrFile, unsigned NumSeconds = 0, unsigned MemoryLimit = 0, std::string *ErrMsg = nullptr) { - const StringRef *Redirects[3] = { &StdInFile, &StdOutFile, &StdErrFile }; - return sys::ExecuteAndWait(ProgramPath, Args, nullptr, Redirects, - NumSeconds, MemoryLimit, ErrMsg); + const StringRef *Redirects[3] = {&StdInFile, &StdOutFile, &StdErrFile}; + return sys::ExecuteAndWait(ProgramPath, Args, nullptr, Redirects, NumSeconds, + MemoryLimit, ErrMsg); } /// RunProgramRemotelyWithTimeout - This function runs the given program @@ -76,13 +70,12 @@ static int RunProgramWithTimeout(StringRef ProgramPath, /// code otherwise. /// @see sys::Program::ExecuteAndWait static int RunProgramRemotelyWithTimeout(StringRef RemoteClientPath, - const char **Args, - StringRef StdInFile, + const char **Args, StringRef StdInFile, StringRef StdOutFile, StringRef StdErrFile, unsigned NumSeconds = 0, unsigned MemoryLimit = 0) { - const StringRef *Redirects[3] = { &StdInFile, &StdOutFile, &StdErrFile }; + const StringRef *Redirects[3] = {&StdInFile, &StdOutFile, &StdErrFile}; // Run the program remotely with the remote client int ReturnCode = sys::ExecuteAndWait(RemoteClientPath, Args, nullptr, @@ -112,7 +105,7 @@ static int RunProgramRemotelyWithTimeout(StringRef RemoteClientPath, return ReturnCode; } -static std::string ProcessFailure(StringRef ProgPath, const char** Args, +static std::string ProcessFailure(StringRef ProgPath, const char **Args, unsigned Timeout = 0, unsigned MemoryLimit = 0) { std::ostringstream OS; @@ -151,44 +144,41 @@ static std::string ProcessFailure(StringRef ProgPath, const char** Args, // LLI Implementation of AbstractIntepreter interface // namespace { - class LLI : public AbstractInterpreter { - std::string LLIPath; // The path to the LLI executable - std::vector<std::string> ToolArgs; // Args to pass to LLI - public: - LLI(const std::string &Path, const std::vector<std::string> *Args) +class LLI : public AbstractInterpreter { + std::string LLIPath; // The path to the LLI executable + std::vector<std::string> ToolArgs; // Args to pass to LLI +public: + LLI(const std::string &Path, const std::vector<std::string> *Args) : LLIPath(Path) { - ToolArgs.clear (); - if (Args) { ToolArgs = *Args; } + ToolArgs.clear(); + if (Args) { + ToolArgs = *Args; } + } - int ExecuteProgram(const std::string &Bitcode, - const std::vector<std::string> &Args, - const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, - const std::vector<std::string> &CCArgs, - const std::vector<std::string> &SharedLibs = - std::vector<std::string>(), - unsigned Timeout = 0, - unsigned MemoryLimit = 0) override; - }; + int ExecuteProgram( + const std::string &Bitcode, const std::vector<std::string> &Args, + const std::string &InputFile, const std::string &OutputFile, + std::string *Error, const std::vector<std::string> &CCArgs, + const std::vector<std::string> &SharedLibs = std::vector<std::string>(), + unsigned Timeout = 0, unsigned MemoryLimit = 0) override; +}; } int LLI::ExecuteProgram(const std::string &Bitcode, const std::vector<std::string> &Args, const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, + const std::string &OutputFile, std::string *Error, const std::vector<std::string> &CCArgs, const std::vector<std::string> &SharedLibs, - unsigned Timeout, - unsigned MemoryLimit) { - std::vector<const char*> LLIArgs; + unsigned Timeout, unsigned MemoryLimit) { + std::vector<const char *> LLIArgs; LLIArgs.push_back(LLIPath.c_str()); LLIArgs.push_back("-force-interpreter=true"); for (std::vector<std::string>::const_iterator i = SharedLibs.begin(), - e = SharedLibs.end(); i != e; ++i) { + e = SharedLibs.end(); + i != e; ++i) { LLIArgs.push_back("-load"); LLIArgs.push_back((*i).c_str()); } @@ -199,26 +189,25 @@ int LLI::ExecuteProgram(const std::string &Bitcode, LLIArgs.push_back(Bitcode.c_str()); // Add optional parameters to the running program from Argv - for (unsigned i=0, e = Args.size(); i != e; ++i) + for (unsigned i = 0, e = Args.size(); i != e; ++i) LLIArgs.push_back(Args[i].c_str()); LLIArgs.push_back(nullptr); - outs() << "<lli>"; outs().flush(); + outs() << "<lli>"; + outs().flush(); DEBUG(errs() << "\nAbout to run:\t"; - for (unsigned i=0, e = LLIArgs.size()-1; i != e; ++i) - errs() << " " << LLIArgs[i]; - errs() << "\n"; - ); - return RunProgramWithTimeout(LLIPath, &LLIArgs[0], - InputFile, OutputFile, OutputFile, - Timeout, MemoryLimit, Error); + for (unsigned i = 0, e = LLIArgs.size() - 1; i != e; ++i) errs() + << " " << LLIArgs[i]; + errs() << "\n";); + return RunProgramWithTimeout(LLIPath, &LLIArgs[0], InputFile, OutputFile, + OutputFile, Timeout, MemoryLimit, Error); } -void AbstractInterpreter::anchor() { } +void AbstractInterpreter::anchor() {} #if defined(LLVM_ON_UNIX) const char EXESuffix[] = ""; -#elif defined (LLVM_ON_WIN32) +#elif defined(LLVM_ON_WIN32) const char EXESuffix[] = "exe"; #endif @@ -248,11 +237,11 @@ static std::string PrependMainExecutablePath(const std::string &ExeName, } // LLI create method - Try to find the LLI executable -AbstractInterpreter *AbstractInterpreter::createLLI(const char *Argv0, - std::string &Message, - const std::vector<std::string> *ToolArgs) { +AbstractInterpreter * +AbstractInterpreter::createLLI(const char *Argv0, std::string &Message, + const std::vector<std::string> *ToolArgs) { std::string LLIPath = - PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t) & createLLI); + PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t)&createLLI); if (!LLIPath.empty()) { Message = "Found lli: " + LLIPath + "\n"; return new LLI(LLIPath, ToolArgs); @@ -269,42 +258,36 @@ AbstractInterpreter *AbstractInterpreter::createLLI(const char *Argv0, // example, to compile a bitcode fragment without linking or executing, then // using a custom wrapper script to check for compiler errors. namespace { - class CustomCompiler : public AbstractInterpreter { - std::string CompilerCommand; - std::vector<std::string> CompilerArgs; - public: - CustomCompiler(const std::string &CompilerCmd, - std::vector<std::string> CompArgs) - : CompilerCommand(CompilerCmd), CompilerArgs(std::move(CompArgs)) {} - - void compileProgram(const std::string &Bitcode, - std::string *Error, - unsigned Timeout = 0, - unsigned MemoryLimit = 0) override; - - int ExecuteProgram(const std::string &Bitcode, - const std::vector<std::string> &Args, - const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, - const std::vector<std::string> &CCArgs = - std::vector<std::string>(), - const std::vector<std::string> &SharedLibs = - std::vector<std::string>(), - unsigned Timeout = 0, - unsigned MemoryLimit = 0) override { - *Error = "Execution not supported with -compile-custom"; - return -1; - } - }; +class CustomCompiler : public AbstractInterpreter { + std::string CompilerCommand; + std::vector<std::string> CompilerArgs; + +public: + CustomCompiler(const std::string &CompilerCmd, + std::vector<std::string> CompArgs) + : CompilerCommand(CompilerCmd), CompilerArgs(std::move(CompArgs)) {} + + void compileProgram(const std::string &Bitcode, std::string *Error, + unsigned Timeout = 0, unsigned MemoryLimit = 0) override; + + int ExecuteProgram( + const std::string &Bitcode, const std::vector<std::string> &Args, + const std::string &InputFile, const std::string &OutputFile, + std::string *Error, + const std::vector<std::string> &CCArgs = std::vector<std::string>(), + const std::vector<std::string> &SharedLibs = std::vector<std::string>(), + unsigned Timeout = 0, unsigned MemoryLimit = 0) override { + *Error = "Execution not supported with -compile-custom"; + return -1; + } +}; } void CustomCompiler::compileProgram(const std::string &Bitcode, - std::string *Error, - unsigned Timeout, + std::string *Error, unsigned Timeout, unsigned MemoryLimit) { - std::vector<const char*> ProgramArgs; + std::vector<const char *> ProgramArgs; ProgramArgs.push_back(CompilerCommand.c_str()); for (std::size_t i = 0; i < CompilerArgs.size(); ++i) @@ -316,11 +299,10 @@ void CustomCompiler::compileProgram(const std::string &Bitcode, for (unsigned i = 0, e = CompilerArgs.size(); i != e; ++i) ProgramArgs.push_back(CompilerArgs[i].c_str()); - if (RunProgramWithTimeout(CompilerCommand, &ProgramArgs[0], - "", "", "", - Timeout, MemoryLimit, Error)) - *Error = ProcessFailure(CompilerCommand, &ProgramArgs[0], - Timeout, MemoryLimit); + if (RunProgramWithTimeout(CompilerCommand, &ProgramArgs[0], "", "", "", + Timeout, MemoryLimit, Error)) + *Error = + ProcessFailure(CompilerCommand, &ProgramArgs[0], Timeout, MemoryLimit); } //===---------------------------------------------------------------------===// @@ -330,38 +312,34 @@ void CustomCompiler::compileProgram(const std::string &Bitcode, // for example, to invoke a cross compiler for code generation followed by // a simulator that executes the generated binary. namespace { - class CustomExecutor : public AbstractInterpreter { - std::string ExecutionCommand; - std::vector<std::string> ExecutorArgs; - public: - CustomExecutor(const std::string &ExecutionCmd, - std::vector<std::string> ExecArgs) - : ExecutionCommand(ExecutionCmd), ExecutorArgs(std::move(ExecArgs)) {} - - int ExecuteProgram(const std::string &Bitcode, - const std::vector<std::string> &Args, - const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, - const std::vector<std::string> &CCArgs, - const std::vector<std::string> &SharedLibs = - std::vector<std::string>(), - unsigned Timeout = 0, - unsigned MemoryLimit = 0) override; - }; +class CustomExecutor : public AbstractInterpreter { + std::string ExecutionCommand; + std::vector<std::string> ExecutorArgs; + +public: + CustomExecutor(const std::string &ExecutionCmd, + std::vector<std::string> ExecArgs) + : ExecutionCommand(ExecutionCmd), ExecutorArgs(std::move(ExecArgs)) {} + + int ExecuteProgram( + const std::string &Bitcode, const std::vector<std::string> &Args, + const std::string &InputFile, const std::string &OutputFile, + std::string *Error, const std::vector<std::string> &CCArgs, + const std::vector<std::string> &SharedLibs = std::vector<std::string>(), + unsigned Timeout = 0, unsigned MemoryLimit = 0) override; +}; } int CustomExecutor::ExecuteProgram(const std::string &Bitcode, - const std::vector<std::string> &Args, - const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, - const std::vector<std::string> &CCArgs, - const std::vector<std::string> &SharedLibs, - unsigned Timeout, - unsigned MemoryLimit) { - - std::vector<const char*> ProgramArgs; + const std::vector<std::string> &Args, + const std::string &InputFile, + const std::string &OutputFile, + std::string *Error, + const std::vector<std::string> &CCArgs, + const std::vector<std::string> &SharedLibs, + unsigned Timeout, unsigned MemoryLimit) { + + std::vector<const char *> ProgramArgs; ProgramArgs.push_back(ExecutionCommand.c_str()); for (std::size_t i = 0; i < ExecutorArgs.size(); ++i) @@ -373,10 +351,9 @@ int CustomExecutor::ExecuteProgram(const std::string &Bitcode, for (unsigned i = 0, e = Args.size(); i != e; ++i) ProgramArgs.push_back(Args[i].c_str()); - return RunProgramWithTimeout( - ExecutionCommand, - &ProgramArgs[0], InputFile, OutputFile, - OutputFile, Timeout, MemoryLimit, Error); + return RunProgramWithTimeout(ExecutionCommand, &ProgramArgs[0], InputFile, + OutputFile, OutputFile, Timeout, MemoryLimit, + Error); } // Tokenize the CommandLine to the command and the args to allow @@ -400,9 +377,9 @@ static void lexCommand(std::string &Message, const std::string &CommandLine, while (std::string::npos != pos || std::string::npos != lastPos) { std::string token = CommandLine.substr(lastPos, pos - lastPos); if (Command == "") - Command = token; + Command = token; else - Args.push_back(token); + Args.push_back(token); // Skip delimiters. Note the "not_of" lastPos = CommandLine.find_first_not_of(delimiters, pos); // Find next "non-delimiter" @@ -411,9 +388,8 @@ static void lexCommand(std::string &Message, const std::string &CommandLine, auto Path = sys::findProgramByName(Command); if (!Path) { - Message = - std::string("Cannot find '") + Command + - "' in PATH: " + Path.getError().message() + "\n"; + Message = std::string("Cannot find '") + Command + "' in PATH: " + + Path.getError().message() + "\n"; return; } CmdPath = *Path; @@ -424,8 +400,7 @@ static void lexCommand(std::string &Message, const std::string &CommandLine, // Custom execution environment create method, takes the execution command // as arguments AbstractInterpreter *AbstractInterpreter::createCustomCompiler( - std::string &Message, - const std::string &CompileCommandLine) { + std::string &Message, const std::string &CompileCommandLine) { std::string CmdPath; std::vector<std::string> Args; @@ -438,10 +413,9 @@ AbstractInterpreter *AbstractInterpreter::createCustomCompiler( // Custom execution environment create method, takes the execution command // as arguments -AbstractInterpreter *AbstractInterpreter::createCustomExecutor( - std::string &Message, - const std::string &ExecCommandLine) { - +AbstractInterpreter * +AbstractInterpreter::createCustomExecutor(std::string &Message, + const std::string &ExecCommandLine) { std::string CmdPath; std::vector<std::string> Args; @@ -456,8 +430,8 @@ AbstractInterpreter *AbstractInterpreter::createCustomExecutor( // LLC Implementation of AbstractIntepreter interface // CC::FileType LLC::OutputCode(const std::string &Bitcode, - std::string &OutputAsmFile, std::string &Error, - unsigned Timeout, unsigned MemoryLimit) { + std::string &OutputAsmFile, std::string &Error, + unsigned Timeout, unsigned MemoryLimit) { const char *Suffix = (UseIntegratedAssembler ? ".llc.o" : ".llc.s"); SmallString<128> UniqueFile; @@ -477,25 +451,22 @@ CC::FileType LLC::OutputCode(const std::string &Bitcode, LLCArgs.push_back("-o"); LLCArgs.push_back(OutputAsmFile.c_str()); // Output to the Asm file - LLCArgs.push_back(Bitcode.c_str()); // This is the input bitcode + LLCArgs.push_back(Bitcode.c_str()); // This is the input bitcode if (UseIntegratedAssembler) LLCArgs.push_back("-filetype=obj"); - LLCArgs.push_back (nullptr); + LLCArgs.push_back(nullptr); outs() << (UseIntegratedAssembler ? "<llc-ia>" : "<llc>"); outs().flush(); DEBUG(errs() << "\nAbout to run:\t"; - for (unsigned i = 0, e = LLCArgs.size()-1; i != e; ++i) - errs() << " " << LLCArgs[i]; - errs() << "\n"; - ); - if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], - "", "", "", - Timeout, MemoryLimit)) - Error = ProcessFailure(LLCPath, &LLCArgs[0], - Timeout, MemoryLimit); + for (unsigned i = 0, e = LLCArgs.size() - 1; i != e; ++i) errs() + << " " << LLCArgs[i]; + errs() << "\n";); + if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], "", "", "", Timeout, + MemoryLimit)) + Error = ProcessFailure(LLCPath, &LLCArgs[0], Timeout, MemoryLimit); return UseIntegratedAssembler ? CC::ObjectFile : CC::AsmFile; } @@ -509,37 +480,33 @@ void LLC::compileProgram(const std::string &Bitcode, std::string *Error, int LLC::ExecuteProgram(const std::string &Bitcode, const std::vector<std::string> &Args, const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, + const std::string &OutputFile, std::string *Error, const std::vector<std::string> &ArgsForCC, const std::vector<std::string> &SharedLibs, - unsigned Timeout, - unsigned MemoryLimit) { + unsigned Timeout, unsigned MemoryLimit) { std::string OutputAsmFile; - CC::FileType FileKind = OutputCode(Bitcode, OutputAsmFile, *Error, Timeout, - MemoryLimit); + CC::FileType FileKind = + OutputCode(Bitcode, OutputAsmFile, *Error, Timeout, MemoryLimit); FileRemover OutFileRemover(OutputAsmFile, !SaveTemps); std::vector<std::string> CCArgs(ArgsForCC); CCArgs.insert(CCArgs.end(), SharedLibs.begin(), SharedLibs.end()); // Assuming LLC worked, compile the result with CC and run it. - return cc->ExecuteProgram(OutputAsmFile, Args, FileKind, - InputFile, OutputFile, Error, CCArgs, - Timeout, MemoryLimit); + return cc->ExecuteProgram(OutputAsmFile, Args, FileKind, InputFile, + OutputFile, Error, CCArgs, Timeout, MemoryLimit); } /// createLLC - Try to find the LLC executable /// -LLC *AbstractInterpreter::createLLC(const char *Argv0, - std::string &Message, +LLC *AbstractInterpreter::createLLC(const char *Argv0, std::string &Message, const std::string &CCBinary, const std::vector<std::string> *Args, const std::vector<std::string> *CCArgs, bool UseIntegratedAssembler) { std::string LLCPath = - PrependMainExecutablePath("llc", Argv0, (void *)(intptr_t) & createLLC); + PrependMainExecutablePath("llc", Argv0, (void *)(intptr_t)&createLLC); if (LLCPath.empty()) { Message = "Cannot find `llc' in executable directory!\n"; return nullptr; @@ -558,41 +525,37 @@ LLC *AbstractInterpreter::createLLC(const char *Argv0, // JIT Implementation of AbstractIntepreter interface // namespace { - class JIT : public AbstractInterpreter { - std::string LLIPath; // The path to the LLI executable - std::vector<std::string> ToolArgs; // Args to pass to LLI - public: - JIT(const std::string &Path, const std::vector<std::string> *Args) +class JIT : public AbstractInterpreter { + std::string LLIPath; // The path to the LLI executable + std::vector<std::string> ToolArgs; // Args to pass to LLI +public: + JIT(const std::string &Path, const std::vector<std::string> *Args) : LLIPath(Path) { - ToolArgs.clear (); - if (Args) { ToolArgs = *Args; } + ToolArgs.clear(); + if (Args) { + ToolArgs = *Args; } + } - int ExecuteProgram(const std::string &Bitcode, - const std::vector<std::string> &Args, - const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, - const std::vector<std::string> &CCArgs = - std::vector<std::string>(), - const std::vector<std::string> &SharedLibs = - std::vector<std::string>(), - unsigned Timeout = 0, - unsigned MemoryLimit = 0) override; - }; + int ExecuteProgram( + const std::string &Bitcode, const std::vector<std::string> &Args, + const std::string &InputFile, const std::string &OutputFile, + std::string *Error, + const std::vector<std::string> &CCArgs = std::vector<std::string>(), + const std::vector<std::string> &SharedLibs = std::vector<std::string>(), + unsigned Timeout = 0, unsigned MemoryLimit = 0) override; +}; } int JIT::ExecuteProgram(const std::string &Bitcode, const std::vector<std::string> &Args, const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, + const std::string &OutputFile, std::string *Error, const std::vector<std::string> &CCArgs, const std::vector<std::string> &SharedLibs, - unsigned Timeout, - unsigned MemoryLimit) { + unsigned Timeout, unsigned MemoryLimit) { // Construct a vector of parameters, incorporating those from the command-line - std::vector<const char*> JITArgs; + std::vector<const char *> JITArgs; JITArgs.push_back(LLIPath.c_str()); JITArgs.push_back("-force-interpreter=false"); @@ -606,28 +569,28 @@ int JIT::ExecuteProgram(const std::string &Bitcode, } JITArgs.push_back(Bitcode.c_str()); // Add optional parameters to the running program from Argv - for (unsigned i=0, e = Args.size(); i != e; ++i) + for (unsigned i = 0, e = Args.size(); i != e; ++i) JITArgs.push_back(Args[i].c_str()); JITArgs.push_back(nullptr); - outs() << "<jit>"; outs().flush(); + outs() << "<jit>"; + outs().flush(); DEBUG(errs() << "\nAbout to run:\t"; - for (unsigned i=0, e = JITArgs.size()-1; i != e; ++i) - errs() << " " << JITArgs[i]; - errs() << "\n"; - ); + for (unsigned i = 0, e = JITArgs.size() - 1; i != e; ++i) errs() + << " " << JITArgs[i]; + errs() << "\n";); DEBUG(errs() << "\nSending output to " << OutputFile << "\n"); - return RunProgramWithTimeout(LLIPath, &JITArgs[0], - InputFile, OutputFile, OutputFile, - Timeout, MemoryLimit, Error); + return RunProgramWithTimeout(LLIPath, &JITArgs[0], InputFile, OutputFile, + OutputFile, Timeout, MemoryLimit, Error); } /// createJIT - Try to find the LLI executable /// -AbstractInterpreter *AbstractInterpreter::createJIT(const char *Argv0, - std::string &Message, const std::vector<std::string> *Args) { +AbstractInterpreter * +AbstractInterpreter::createJIT(const char *Argv0, std::string &Message, + const std::vector<std::string> *Args) { std::string LLIPath = - PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t) & createJIT); + PrependMainExecutablePath("lli", Argv0, (void *)(intptr_t)&createJIT); if (!LLIPath.empty()) { Message = "Found lli: " + LLIPath + "\n"; return new JIT(LLIPath, Args); @@ -641,9 +604,10 @@ AbstractInterpreter *AbstractInterpreter::createJIT(const char *Argv0, // CC abstraction // -static bool IsARMArchitecture(std::vector<const char*> Args) { - for (std::vector<const char*>::const_iterator - I = Args.begin(), E = Args.end(); I != E; ++I) { +static bool IsARMArchitecture(std::vector<const char *> Args) { + for (std::vector<const char *>::const_iterator I = Args.begin(), + E = Args.end(); + I != E; ++I) { if (StringRef(*I).equals_lower("-arch")) { ++I; if (I != E && StringRef(*I).startswith_lower("arm")) @@ -655,23 +619,21 @@ static bool IsARMArchitecture(std::vector<const char*> Args) { } int CC::ExecuteProgram(const std::string &ProgramFile, - const std::vector<std::string> &Args, - FileType fileType, - const std::string &InputFile, - const std::string &OutputFile, - std::string *Error, - const std::vector<std::string> &ArgsForCC, - unsigned Timeout, - unsigned MemoryLimit) { - std::vector<const char*> CCArgs; + const std::vector<std::string> &Args, FileType fileType, + const std::string &InputFile, + const std::string &OutputFile, std::string *Error, + const std::vector<std::string> &ArgsForCC, + unsigned Timeout, unsigned MemoryLimit) { + std::vector<const char *> CCArgs; CCArgs.push_back(CCPath.c_str()); if (TargetTriple.getArch() == Triple::x86) CCArgs.push_back("-m32"); - for (std::vector<std::string>::const_iterator - I = ccArgs.begin(), E = ccArgs.end(); I != E; ++I) + for (std::vector<std::string>::const_iterator I = ccArgs.begin(), + E = ccArgs.end(); + I != E; ++I) CCArgs.push_back(I->c_str()); // Specify -x explicitly in case the extension is wonky @@ -691,7 +653,7 @@ int CC::ExecuteProgram(const std::string &ProgramFile, } } - CCArgs.push_back(ProgramFile.c_str()); // Specify the input filename. + CCArgs.push_back(ProgramFile.c_str()); // Specify the input filename. CCArgs.push_back("-x"); CCArgs.push_back("none"); @@ -713,27 +675,27 @@ int CC::ExecuteProgram(const std::string &ProgramFile, for (unsigned i = 0, e = ArgsForCC.size(); i != e; ++i) CCArgs.push_back(ArgsForCC[i].c_str()); - CCArgs.push_back("-lm"); // Hard-code the math library... - CCArgs.push_back("-O2"); // Optimize the program a bit... -#if defined (HAVE_LINK_R) - CCArgs.push_back("-Wl,-R."); // Search this dir for .so files + CCArgs.push_back("-lm"); // Hard-code the math library... + CCArgs.push_back("-O2"); // Optimize the program a bit... +#if defined(HAVE_LINK_R) + CCArgs.push_back("-Wl,-R."); // Search this dir for .so files #endif if (TargetTriple.getArch() == Triple::sparc) CCArgs.push_back("-mcpu=v9"); - CCArgs.push_back(nullptr); // NULL terminator + CCArgs.push_back(nullptr); // NULL terminator - outs() << "<CC>"; outs().flush(); + outs() << "<CC>"; + outs().flush(); DEBUG(errs() << "\nAbout to run:\t"; - for (unsigned i = 0, e = CCArgs.size()-1; i != e; ++i) - errs() << " " << CCArgs[i]; - errs() << "\n"; - ); + for (unsigned i = 0, e = CCArgs.size() - 1; i != e; ++i) errs() + << " " << CCArgs[i]; + errs() << "\n";); if (RunProgramWithTimeout(CCPath, &CCArgs[0], "", "", "")) { *Error = ProcessFailure(CCPath, &CCArgs[0]); return -1; } - std::vector<const char*> ProgramArgs; + std::vector<const char *> ProgramArgs; // Declared here so that the destructor only runs after // ProgramArgs is used. @@ -758,7 +720,7 @@ int CC::ExecuteProgram(const std::string &ProgramFile, // Full path to the binary. We need to cd to the exec directory because // there is a dylib there that the exec expects to find in the CWD - char* env_pwd = getenv("PWD"); + char *env_pwd = getenv("PWD"); Exec = "cd "; Exec += env_pwd; Exec += "; ./"; @@ -769,15 +731,15 @@ int CC::ExecuteProgram(const std::string &ProgramFile, // Add optional parameters to the running program from Argv for (unsigned i = 0, e = Args.size(); i != e; ++i) ProgramArgs.push_back(Args[i].c_str()); - ProgramArgs.push_back(nullptr); // NULL terminator + ProgramArgs.push_back(nullptr); // NULL terminator // Now that we have a binary, run it! - outs() << "<program>"; outs().flush(); + outs() << "<program>"; + outs().flush(); DEBUG(errs() << "\nAbout to run:\t"; - for (unsigned i = 0, e = ProgramArgs.size()-1; i != e; ++i) - errs() << " " << ProgramArgs[i]; - errs() << "\n"; - ); + for (unsigned i = 0, e = ProgramArgs.size() - 1; i != e; ++i) errs() + << " " << ProgramArgs[i]; + errs() << "\n";); FileRemover OutputBinaryRemover(OutputBinary.str(), !SaveTemps); @@ -796,17 +758,18 @@ int CC::ExecuteProgram(const std::string &ProgramFile, } return ExitCode; } else { - outs() << "<run remotely>"; outs().flush(); - return RunProgramRemotelyWithTimeout(RemoteClientPath, - &ProgramArgs[0], InputFile, OutputFile, - OutputFile, Timeout, MemoryLimit); + outs() << "<run remotely>"; + outs().flush(); + return RunProgramRemotelyWithTimeout(RemoteClientPath, &ProgramArgs[0], + InputFile, OutputFile, OutputFile, + Timeout, MemoryLimit); } } int CC::MakeSharedObject(const std::string &InputFile, FileType fileType, - std::string &OutputFile, - const std::vector<std::string> &ArgsForCC, - std::string &Error) { + std::string &OutputFile, + const std::vector<std::string> &ArgsForCC, + std::string &Error) { SmallString<128> UniqueFilename; std::error_code EC = sys::fs::createUniqueFile( InputFile + "-%%%%%%%" + LTDL_SHLIB_EXT, UniqueFilename); @@ -816,15 +779,16 @@ int CC::MakeSharedObject(const std::string &InputFile, FileType fileType, } OutputFile = UniqueFilename.str(); - std::vector<const char*> CCArgs; + std::vector<const char *> CCArgs; CCArgs.push_back(CCPath.c_str()); if (TargetTriple.getArch() == Triple::x86) CCArgs.push_back("-m32"); - for (std::vector<std::string>::const_iterator - I = ccArgs.begin(), E = ccArgs.end(); I != E; ++I) + for (std::vector<std::string>::const_iterator I = ccArgs.begin(), + E = ccArgs.end(); + I != E; ++I) CCArgs.push_back(I->c_str()); // Compile the C/asm file into a shared object @@ -833,25 +797,25 @@ int CC::MakeSharedObject(const std::string &InputFile, FileType fileType, CCArgs.push_back(fileType == AsmFile ? "assembler" : "c"); } CCArgs.push_back("-fno-strict-aliasing"); - CCArgs.push_back(InputFile.c_str()); // Specify the input filename. + CCArgs.push_back(InputFile.c_str()); // Specify the input filename. CCArgs.push_back("-x"); CCArgs.push_back("none"); if (TargetTriple.getArch() == Triple::sparc) - CCArgs.push_back("-G"); // Compile a shared library, `-G' for Sparc + CCArgs.push_back("-G"); // Compile a shared library, `-G' for Sparc else if (TargetTriple.isOSDarwin()) { // link all source files into a single module in data segment, rather than // generating blocks. dynamic_lookup requires that you set // MACOSX_DEPLOYMENT_TARGET=10.3 in your env. FIXME: it would be better for // bugpoint to just pass that in the environment of CC. CCArgs.push_back("-single_module"); - CCArgs.push_back("-dynamiclib"); // `-dynamiclib' for MacOS X/PowerPC + CCArgs.push_back("-dynamiclib"); // `-dynamiclib' for MacOS X/PowerPC CCArgs.push_back("-undefined"); CCArgs.push_back("dynamic_lookup"); } else - CCArgs.push_back("-shared"); // `-shared' for Linux/X86, maybe others + CCArgs.push_back("-shared"); // `-shared' for Linux/X86, maybe others if (TargetTriple.getArch() == Triple::x86_64) - CCArgs.push_back("-fPIC"); // Requires shared objs to contain PIC + CCArgs.push_back("-fPIC"); // Requires shared objs to contain PIC if (TargetTriple.getArch() == Triple::sparc) CCArgs.push_back("-mcpu=v9"); @@ -860,24 +824,20 @@ int CC::MakeSharedObject(const std::string &InputFile, FileType fileType, CCArgs.push_back(OutputFile.c_str()); // Output to the right filename. CCArgs.push_back("-O2"); // Optimize the program a bit. - - // Add any arguments intended for CC. We locate them here because this is // most likely -L and -l options that need to come before other libraries but // after the source. Other options won't be sensitive to placement on the // command line, so this should be safe. for (unsigned i = 0, e = ArgsForCC.size(); i != e; ++i) CCArgs.push_back(ArgsForCC[i].c_str()); - CCArgs.push_back(nullptr); // NULL terminator + CCArgs.push_back(nullptr); // NULL terminator - - - outs() << "<CC>"; outs().flush(); + outs() << "<CC>"; + outs().flush(); DEBUG(errs() << "\nAbout to run:\t"; - for (unsigned i = 0, e = CCArgs.size()-1; i != e; ++i) - errs() << " " << CCArgs[i]; - errs() << "\n"; - ); + for (unsigned i = 0, e = CCArgs.size() - 1; i != e; ++i) errs() + << " " << CCArgs[i]; + errs() << "\n";); if (RunProgramWithTimeout(CCPath, &CCArgs[0], "", "", "")) { Error = ProcessFailure(CCPath, &CCArgs[0]); return 1; @@ -887,9 +847,8 @@ int CC::MakeSharedObject(const std::string &InputFile, FileType fileType, /// create - Try to find the CC executable /// -CC *CC::create(std::string &Message, - const std::string &CCBinary, - const std::vector<std::string> *Args) { +CC *CC::create(std::string &Message, const std::string &CCBinary, + const std::vector<std::string> *Args) { auto CCPath = sys::findProgramByName(CCBinary); if (!CCPath) { Message = "Cannot find `" + CCBinary + "' in PATH: " + |
